Supabase Tops 50M Databases as AI Agents Drive 70% of Activity
Y Combinator
As autonomous agents commoditize code generation, personal databases will become the primary system of record for billions of custom applications, rendering off-the-shelf software and bloated venture teams obsolete.
Supabase experienced massive AI-driven acceleration, scaling from 3 million to 13 million users and 8 million to nearly 50 million databases under management, with approximately 70% of new activity initiated by autonomous AI agents. (0:00)
The company has transitioned across three distinct operational eras, shifting from a human dashboard UI to an API-first platform, and finally to a code-first, CLI-based architecture tailored specifically for agentic execution environments like Claude Code and Codex. (2:35)
To prepare for a potential scale of over one billion databases per month, Supabase acquired Turso to leverage low-overhead SQLite compatibility via 'Supabase Spark' on the prototyping side, while scaling up to petabyte clusters with Multigres. (15:56)
Internal AI coding adoption at Supabase climbed from 10% to 60% of engineers generating over 80% of their code via AI assistants within six months, re-anchoring developer focus toward automated testing and evaluation infrastructure. (17:58)
Detailed notes
## Background
Published by Y Combinator on YouTube on October 30, 2026, this episode of the Lightcone podcast features Supabase co-founder and CEO Paul Copplestone. According to the page description, the discussion explores Supabase's explosive growth to 13 million users and over 50 million managed databases since its Summer 2020 batch, examining how the company is positioning for a future driven by autonomous AI agents, personal databases, and universally accessible software creation.
## TL;DR
Supabase CEO Paul Copplestone joins the Lightcone hosts to analyze how coding agents like Claude Code and Codex are fundamentally transforming database architecture and developer behavior. As autonomous agents now drive roughly 70% of new platform activity, Supabase has transitioned from visual dashboards to a CLI- and code-first infrastructure designed for automated self-healing and dynamic retrieval. The conversation details how non-technical builders are assembling custom, personal databases for health and finance, challenging traditional enterprise-first SaaS paradigms. Ultimately, the panel argues that extreme AI leverage allows ultra-lean teams to build massive, highly profitable businesses without traditional venture funding, anchored by evergreen technologies like PostgreSQL.
## Atmosphere & style
The conversation carries an energetic, tech-insider buzz, oscillating between lighthearted banter about coding via phone call in bed and deep technical analysis of dynamic evals and retrieval architectures. The hosts and Copplestone share an easy, collaborative rapport, rooted in mutual YC history and firsthand enthusiasm for dogfooding their own automated agent setups. It feels less like an investor pitch and more like a late-night hacking debrief, marked by genuine awe at how rapidly engineering norms are collapsing into conversational prompts and automated loops.
## Bulletin
- [00:00](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=0s) Supabase experienced massive AI-driven acceleration, scaling from 3 million to 13 million users and 8 million to nearly 50 million databases under management, with approximately 70% of new activity initiated by autonomous AI agents.
- [02:35](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=155s) The company has transitioned across three distinct operational eras, shifting from a human dashboard UI to an API-first platform, and finally to a code-first, CLI-based architecture tailored specifically for agentic execution environments like Claude Code and Codex.
- [15:56](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=956s) To prepare for a potential scale of over one billion databases per month, Supabase acquired Turso to leverage low-overhead SQLite compatibility via 'Supabase Spark' on the prototyping side, while scaling up to petabyte clusters with Multigres.
- [17:58](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1078s) Internal AI coding adoption at Supabase climbed from 10% to 60% of engineers generating over 80% of their code via AI assistants within six months, re-anchoring developer focus toward automated testing and evaluation infrastructure.
## Key takeaways
- [00:00](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=0s) Roughly 70% of new activity on Supabase is driven directly by autonomous agents rather than human clicks, inverting YC's classic motto from 'make something people want' to 'make something agents want'.
- [02:35](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=155s) Open-source software gives agents a fundamental diagnostic advantage over closed-source SaaS by allowing models to inspect underlying code and self-heal when execution errors occur.
- [04:34](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=274s) The scarce skill in technology has shifted from technical implementation ('how to build') to domain expertise and product taste ('what to build'), enabling non-programmers to deploy production applications immediately.
- [08:42](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=522s) Drastically lowered engineering friction enables hyper-niche, localized personal software—such as a 50-year-old Brazilian taxi driver creating his own bespoke regional ride-hailing app from a mobile phone.
- [11:31](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=691s) Owning an independent personal database serves as an essential, un-siloed source of truth, enabling cross-domain intelligence (such as correlating workout trends with travel calendars) and preventing lock-in to any single AI provider.
- [15:56](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=956s) To bridge the gap between lightweight toy experiments and enterprise infrastructure, Supabase leverages Turso's SQLite architecture for micro-workloads while supporting enterprise footprints with Multigres.
- [28:51](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1731s) Developer tool error messages must be rewritten with actionable remediation instructions and documentation links embedded directly into outputs so autonomous agents can self-resolve blockers without stalling.
- [32:16](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1936s) Even with multi-million token context windows, agentic workflows face severe context limits when navigating vast personal archives, requiring hybrid vector search and SQL-based graph databases for precise context synthesis.
- [35:40](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2140s) Continuous evaluation frameworks and autonomous research loops allow AI systems to benchmark retrieval performance, commit optimizations directly to master, and practice recursive self-improvement on domain tasks.
- [41:50](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2510s) Extremely high leverage from AI engineering tools enables lean teams of 10 to 15 people to bootstrap software businesses to $10M–$50M in ARR, bypassing traditional Series A venture capital treadmills altogether.
- [45:35](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2735s) Relying on the Lindy effect of durable relational database primitives and aggressive internal dogfooding protects developer tooling companies from mid-lifecycle stagnation as software delivery paradigms evolve.
Paul Copplestone opens with an optimistic outlook on the democratization of software development, declaring that access to AI is transforming everyday users into creators who no longer have to wait on someone else to tweak an app or interface. On the Lightcone podcast, the hosts introduce Paul, the co-founder and CEO of Supabase—the open-source Postgres backend that has turned into the default data layer for agentic coding tools like Claude Code and Codex. The hosts joke about Y Combinator’s iconic motto given to founders on day one, noting that while YC famously hands out shirts reading *“Make something people want,”* the reality in 2026 has rapidly shifted toward making something AI agents want. At Supabase, roughly 70% of all new activity is now driven by autonomous agents rather than direct human clicks.
The scale of this inflection over the preceding twelve months is massive across every core operational metric. Paul explains that signups surged from roughly 3 million a year prior to 13 million, while revenue is on track to grow 4x within the year. The platform spins up more than a million databases each week, pushing total databases under management toward 50 million, up from just 8 million a year ago. When asked what is fueling this hockey-stick adoption, Paul attributes it to two forces: traditional software engineers building with sheer abandon, and an influx of non-engineers who can suddenly stand up full-stack applications on Supabase without a computer science background. As Paul Copplestone summarizes the overarching trajectory: “I certainly think that it'll be the case that everyone in the world with access to AI will become a builder of some sort.”
- **Total signups:** Surged from ~3 million to 13 million over a 12-month span.
- **Databases under management:** Grown from 8 million to nearly 50 million.
- **Weekly creation rate:** Exceeding 1 million new databases provisioned per week.
- **Revenue trajectory:** Pacing at 4x year-over-year growth.
- **Agent activity share:** Approximately 70% of new platform activity is generated by AI agents.
[02:35](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=155s) The Three Eras of Supabase and the Open-Source Edge with Agents
To understand why AI agents naturally gravitate toward Supabase, Paul describes the company's evolution through three distinct product phases. Supabase originated as a dashboard-first product for human operators to click through tables, transitioned into an API-centric company, and has now evolved into a code-first, CLI-driven platform. Because autonomous agents fundamentally prefer interacting with terminal CLIs, scripts, and code rather than navigating visual GUIs, Supabase’s code-first environment aligned seamlessly with what LLM coding engines require. Combined with the timing of becoming the baked-in default database choice inside leading frontier models, Supabase captured agentic workflows right as the wave hit.
```mermaid
flowchart LR
accTitle: The Three Eras of Supabase
accDescr: Evolution of Supabase from dashboard-first to API-first to code-first modalities for human and agent builders.
subgraph E1["Era 1: Visual"]
A["Dashboard Company<br/>(GUI tables & manual config)"]
end
subgraph E2["Era 2: Programmatic"]
B["API Company<br/>(REST & client libraries)"]
end
subgraph E3["Era 3: Agentic"]
C["Code-First Company<br/>(CLI & terminal-driven)"]
D["Agent Integration<br/>(Claude Code, Codex defaults)"]
C --> D
end
A --> B
B --> C
```
Being open source has also served as a massive structural advantage for agent adoption. Supabase not only open-sources its own stack but actively maintains foundational ecosystem utilities like PostgREST, creating sprawling goodwill and deep documentation across the broader Postgres community. As the hosts observe, agents thrive on transparency: when an agent runs into an execution error, hitting a proprietary closed-source wall leaves it stranded, whereas an open repository allows the model to inspect the underlying source code and self-heal. Paul notes this will become equally critical for enterprise software procurement: “I think it's going to be increasingly important as well because now with you know security being so important I think a lot of the say enterprises are going to want to inspect the source code to know that it's secure and if you've got closed source code then you probably won't want to adopt them as a vendor.”
[04:34](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=274s) The Rise of “Builders” Over Traditional Software Engineers
The profile of Supabase’s user base is undergoing a fundamental transformation away from solely classical developers toward a broad class of “builders.” Historically, when software companies experience massive top-of-funnel acceleration, downstream funnel health metrics—such as activation, retention, and paid conversion—deteriorate due to low-intent traffic. Instead, Supabase is seeing all conversion metrics rise simultaneously, driven by LLMs becoming competent enough to carry non-technical users all the way through deployment. Investors had previously cautioned the Supabase founders that product-led growth (PLG) would hit an inevitable revenue ceiling without pivoting entirely to enterprise sales, but Paul remarks that the influx of new builders has broken every expected ceiling.
The hosts point out that YC’s own perspective on founding teams has mirrored this evolution. Between 2022 and 2025, YC doubled down on the dogma that startups strictly required technical co-founders to build the product. However, as coding has become an on-demand commodity, the scarce skill has shifted from *how* to build to *what* to build. The host highlights this exact dynamic: “I mean the much harder thing to do is to know what to build.” Domain experts who previously possessed deep market knowledge but lacked coding chops were historically held back because they could never convince an engineer to leave a high-paying job to work on a niche problem. Today, these founders build functional software immediately. A host shares the story of a fintech founder who recently sold his company for over $1 billion: despite possessing only undergraduate math and basic Ruby scripting knowledge, he is now writing full custom integrations directly against banking APIs to track his private balance sheets without hiring a single developer.
[08:42](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=522s) Building for Oneself: Niche Software and the Brazilian Taxi Driver
This sudden collapse in development friction enables a long tail of hyper-personalized, single-user, or hyper-local applications that never would have received venture capital or engineering buy-in in the past. These applications range from private internal operational dashboards to localized consumer utilities built strictly for the creator's immediate community.
Paul shares a memorable encounter from a recent Supabase user conference where an attendee from Brazil approached him to showcase what he had created. The user was a 50-year-old taxi driver who had managed to program and launch an entire regional taxi hailing application—effectively a mini-Uber customized for his specific local city—entirely from his mobile phone. Paul reflects on the sheer vitality of seeing non-traditional users pick up these tools: “He was like 50 years old or something like that, but he had the energy of a like teenager building suddenly, which I think is kind of cool because now it's kind of getting to that stage where I I think it's a little bit there's so much uncertainty around like what is the future of work going to look like but in this category of builders there's that excitement of the future and that's really what I love about Supabase it's like something that people can come in and those who are uncertain now are discovering this skill.”
[09:53](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=593s) Building Personal Software and "Control Tower"
Harj Taggar shares the personal software he has been hacking together over recent weeks, admitting to an evolving philosophy around tools. Six months earlier, after becoming hooked on Claude, he boldly claimed that software would no longer need user interfaces and that everything would simply happen through conversational chat. He was also fiercely opposed to using a database, convinced that plain Markdown files would suffice for everything. Eventually, reality caught up: he hit a threshold where structured databases became genuinely useful and visual interfaces were indispensable. He built a system he calls "Control Tower" to manage every facet of his life, including an interface that triages his incoming emails so he never has to wade through an inbox, as well as tracking systems for health, body weight, and workouts.
The finance module of his custom app particularly surprised him. Harj realized that his bespoke tool had achieved feature parity with dedicated consumer finance products like Mint or Monarch, and in many ways had surpassed them because of its deep access to personal context. Instead of relying on generic merchant categorizations, the app cross-references transaction descriptions with his personal knowledge base to identify who a person is and classify the expense accurately. As Harj reflected on building what used to require venture-backed startups just for personal use: “And that was like a whole company like several startups just doing personal finance and then you just like build it for yourself and I don't need it to work for anyone else or like have anyone else's opinion on it.”
- **Control Tower features**: Custom email triage UI, personal finance tracking, and unified health tracking (weights, workouts).
- **Personal context advantage**: Cross-references transaction metadata with personal notes and contacts to categorize expenses accurately.
- **Evolving philosophy**: Transitioned from believing in "no UIs and only chat/Markdown" to acknowledging that real-world workflows inevitably require structured databases and purpose-built UIs.
```mermaid
flowchart TD
accTitle: Personal Data Architecture
accDescr: Personal life inputs feeding into a central database powering custom agents and interfaces.
subgraph Inputs["Personal Life Inputs"]
E["Email Stream"]
F["Bank Transactions"]
H["Health & Workouts"]
C["Calendar Events"]
end
subgraph Core["Single Store of Record"]
DB[("Supabase Personal Database & Storage")]
end
Inputs --> DB
DB <--> Engines
Engines --> Views
```
[11:31](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=691s) The Database as the Source of Truth for Personal Agents
Paul Copplestone and the hosts observe that health and finance are consistently the two initial domains where people insist on owning their underlying data. The real magic occurs when disconnected devices sync into a single database, allowing an agent to establish cross-domain correlations that siloed commercial applications cannot see. For instance, when an agent detects an unexpected uptick in weight, it checks the user's calendar, realizes they were traveling for work, and intelligently reassures them rather than sounding an alarm.
At the same time, power users are growing cautious about vendor lock-in with monolithic AI agents. If all personal routines, contact histories, and CRM data become trapped inside a single proprietary agent wrapper, switching tools becomes nearly impossible. Extracting that intelligence into an independent database ensures that the user retains the permanent store of record and can hot-swap different AI agents on top of their own infrastructure. As Harj pointed out: “Like you don't you want to own your own database and then build all the applications or agents on top of it versus having that all in like someone else's database.” This flips the historical model of computing on its head; historically, databases were massive, complex engines maintained exclusively by large enterprises because writing code to interact with them was far out of reach for average individuals.
- **Cross-domain correlation**: A unified database lets AI connect health metrics directly with calendar travel data.
- **Agent independence**: Maintaining the database as the independent system of record prevents routines and personal CRM data from becoming captive to any single AI provider.
- **File ingest pipeline**: Users dump raw documents and forwards into an S3-compatible Supabase storage bucket, where downstream agents parse relevance and route the data automatically.
[14:15](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=855s) From Developers to Billions of Builders
The discussion shifts to whether every human being on the planet will eventually operate their own personal database containing their health, finances, and relationships. Paul explains that Supabase operates fundamentally as an index company: when they joined Y Combinator in the Summer 2020 batch, their initial goal was simply to power every YC startup on day one. While that founding philosophy has not shifted, the aperture has expanded by several orders of magnitude. With AI lowering the barrier to entry, anyone who can prompt a model effectively becomes a software builder who no longer has to tolerate the compromises of off-the-shelf software.
This shift triggers staggering infrastructure implications. Supabase already spins up around 1 million new databases every single week, but widespread agent adoption points toward a much higher ceiling. If ChatGPT's reported 1.2 billion weekly active users were each to deploy just one project or database per month, infrastructure providers would need to provision 1.2 billion databases monthly. Paul highlights the unprecedented nature of this shift: “And so that's like the scale that we're moving towards architectures that we need to have so that we can actually cater for for that scale which is something that has never had to happen before on the database database realm.”
- **Scale comparison**: Provisioning 1 million databases weekly today versus a projected future of handling over a billion databases per month.
- **Index company strategy**: Originally focused on indexing YC founders on day one, now aiming to be the default backend for global AI builders.
- **Custom software empowerment**: Non-developers can tailor and tweak applications to their idiosyncratic preferences rather than relying on vendor roadmaps.
[15:56](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=956s) Scaling from Prototype to Petabytes: The Dual-Architecture Bet
Meeting billion-database scale prompted the question of whether PostgreSQL can sustain such workloads or if Supabase must invent an entirely new database engine. Paul quips that better negotiations with AWS would certainly help, but emphasizes that provisioning heavy, full-blown database instances—akin to buying a "Ferrari"—for lightweight toy apps and early experiments is fundamentally impractical. To bridge this gap, Supabase acquired Turso, whose architecture provides deep compatibility with both PostgreSQL and SQLite. SQLite's hyper-lightweight footprint makes it ideal for rapid prototyping and micro-workloads.
This acquisition underpins a new tier called "Supabase Spark," designed to let users start seamlessly on low-overhead architectures and smoothly scale up to petabyte-scale PostgreSQL enterprise clusters without rewriting their applications. While classic venture wisdom urged database companies to chase enterprise Oracle-style contracts as quickly as possible, Supabase is actively fighting on both fronts simultaneously. They are scaling down to SQLite-style prototypes via Turso while simultaneously scaling up to multi-petabyte enterprise instances via their Multigres architecture. As Paul notes regarding the difficulty of balancing extreme enterprise scale with frictionless onboarding: “Basically we've got two products that cater on the two ends. So Multigres scale up to petabytes and then Turso scale down to like these prototyping and SQLite type workloads.”
- **Supabase Spark**: A lightweight tier leveraging Turso's SQLite- and Postgres-compatible architecture for early-stage and personal workloads.
- **Prototype to Petabytes**: The overarching company thesis ensuring seamless migration from hobbyist projects to massive enterprise footprints.
- **Dual-end product focus**: Running Multigres for multi-petabyte scaling while using Turso to scale down economically for billions of lightweight databases.
[17:58](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1078s) Internal AI Adoption and the Surge in Automated Testing
The conversation turns to how engineering work inside Supabase has radically transformed over the preceding six months. Paul revealed the results of an internal company poll: half a year prior, only 10% of their engineers were writing 80% or more of their code using AI coding agents; within just six months, that metric surged to 60%. Supabase intentionally avoided imposing top-down AI mandates or prescriptive corporate policies, choosing instead to grant developers unfettered access to whatever frontier tools they wished to try. The rapid shift occurred organically as engineers realized modern models could reliably handle complex, non-trivial engineering tasks well beyond boilerplate.
Because the velocity and sheer volume of AI-generated code has spiked dramatically, Supabase has had to re-anchor its development culture around rigorous verification and automated testing. Rather than human line-by-line inspection, the engineering team relies heavily on advanced testing frameworks and developer tooling—mirroring a broader trend across YC startups like Blacksmith, Depot, and Ubicloud—to ensure that generated systems operate securely and reliably in production environments. As Paul described the cultural change: “So we don't have an AI policy internally. We just let people do whatever they whatever they want and we give them access to to whatever tools they they want to use.”
- **Internal AI code generation surge**: Supabase engineers writing 80%+ of their code via AI assistants climbed from 10% to 60% in six months.
- **No official AI mandate**: Adoption spread purely through individual tool efficacy and developer autonomy rather than management edicts.
- **Shift toward testing infrastructure**: High code generation volume shifts developer responsibility toward heavy automated testing suites and CI tooling.
[19:09](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1149s) Model Breakthroughs and the Three Eras of Supabase
The discussion opens on how developer behavior has fundamentally shifted around modern CI systems, test suites, and AI-assisted code reviews. While engineers were skeptical earlier in the year, models have progressed so rapidly—tackling complex scientific reasoning like the Navier-Stokes equations—that the broader engineering community is now convinced AI coding has broken completely new ground.
```mermaid
flowchart LR
accTitle: The Three Eras of Supabase
accDescr: Evolution of Supabase from a dashboard-first UI to an API-first backend to a code-first agent platform.
A["Era 1: Dashboard First<br/>(YC S20 / 100 Days)<br/>Airtable-like UI for Postgres"] --> B["Era 2: API First<br/>(2021–2024)<br/>Programmable DBs for Bolt, Lovable"]
B --> C["Era 3: Agent First<br/>(Current Era)<br/>Git-native, CLI sandboxes, code-first"]
```
The hosts ask Paul Copplestone to reflect on the three distinct eras of Supabase: first starting out as a dashboard company built in 100 days during YC, pivoting into an API company, and now entering the “make something agents want” era. Copplestone recalls that starting a database company during YC initially felt intensely contrarian:
- **Era 1 (Dashboard First):** Software engineers struggled with the sheer difficulty of using relational databases. Copplestone loved Airtable and wanted to place an intuitive Airtable-like spreadsheet UI directly on top of Postgres.
- **Era 2 (API First):** Around 2021, a partner integrated with Supabase and demanded an API to spin up massive fleets of databases automatically. That pivot set Supabase up perfectly for 2024, becoming the default data backend when AI app generators like Bolt and Lovable emerged.
- **Era 3 (Agent / Code First):** Copplestone noticed that developers and agents completely stopped visiting the web dashboard. In response, he issued an internal product memo mandating that Supabase become strictly code-first and Git-native: “If it exists on the dashboard, it basically has to work in lock step in code infrastructure as code essentially and we rearchitected a lot of the CLI and everything to work in sandboxes in code.”
---
[22:03](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1323s) Mobile Waves, Heroku's Legacy, and the AWS Scaling Playbook
The conversation turns to historical predecessors like Parse and Firebase, both YC alumni that paved the way for modern developer platforms before being acquired by Meta and Google, respectively. Back in 2014, spinning up anything other than Amazon RDS seemed absurd. However, MongoDB’s aggressive push for NoSQL alongside the explosion of mobile iPhone apps created market inflections where clean RESTful APIs became indispensable. MongoDB Atlas and Firebase ultimately proved that standalone database platforms could thrive outside of the three hyperscalers.
The hosts compare Supabase's trajectory to Heroku. While Heroku popularized Postgres and mastered initial developer experience (DX), it famously struggled to keep companies from migrating away once their apps scaled up and required deeper performance tuning. When the hosts ask whether Supabase can avoid that fate or simply dominate the ballooning early-stage market, Copplestone responds: “Well, we want it all. So, so we might not have to, but uh we'll definitely do it.” Postgres was nascent during Heroku's prime, whereas Supabase has wrapped Postgres in modern tooling and connection infrastructure designed to scale indefinitely.
Copplestone highlights the core economic lesson borrowed directly from AWS:
- An estimated 40% of AWS revenue comes from startups that built on them on day one and scaled into tech giants.
- Migrating databases in production is technically perilous and near impossible for mature companies, meaning winning day one locks in long-term customer retention.
- Replicating the Stripe/AWS playbook—capturing founders on day one and scaling alongside the fastest-growing companies in the world across an entire generation—creates an enduring, generational business.
---
[25:39](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1539s) Consumer Databases and Dogfooding Personal AI Agents
While winning day one used to mean pitching YC batch founders, the rise of AI means anyone can be a builder. This shift splits the database market into two distinct categories: high-growth startup backends, and a brand-new direct-to-consumer (prosumer) tier that historically sounded like a complete syntax error. Individual consumers now use Supabase to power personal finance tools, custom tracking setups, or small local businesses. Because consumers continuously generate and retain personal records, their databases grow steadily over the course of their lives, providing an unexpected, sticky expansion vector for Supabase.
```mermaid
flowchart TD
accTitle: Dual-Segment Growth Engine
accDescr: Comparison of enterprise startup scale versus cumulative prosumer database growth.
subgraph Enterprise["Startups & Scale-ups"]
E1["Day 1 Startups"] --> E2["Fastest-growing companies"]
E2 --> E3["Generational cloud revenue"]
end
subgraph Prosumer["Direct-to-Consumer / Agents"]
P1["Individual Builders & Agents"] --> P2["Lifelong data accumulation"]
P2 --> P3["Sticky, compounding index of personal life"]
end
```
Copplestone explains that his own conviction around personal agents surged after his executive assistant went away on leave for a week. Forced to rely entirely on automated agents, he realized how capable they had become. To ensure Supabase builds the right primitives for this paradigm, he enforces a strict personal dogfooding rule:
- He builds personal agent workflows using voice tools like Dot, chatting continuously over the phone to command application changes.
- He purposefully forbids himself from inspecting the underlying codebase or micro-managing the architecture, intervening only to verify that the end-state implementation actually works.
- Copplestone remarks: “If you had shown someone this 6 months ago, they would have just thought it was impossible.”
[28:51](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1731s) Conferences for Agents and Designing Agent-First Error Messages
Reflecting on attending a Supabase Select conference a couple of weeks prior, one host jokes about a wild realization: listening to all the exciting features Supabase was rolling out felt unnecessary for a human developer. Instead of attending personally, developers could simply send an agent to sit through the conference, absorb every update, and figure out how to integrate those features directly into their codebase. This sparks banter about running a truly virtual live conference exclusively attended by agents talking to each other, exchanging tips, or downloading markdown files dropped into the audience—jokingly dubbed the "artifactory."
Turning to practical implementation, the conversation pivots to how dev tools need to re-architect themselves to appeal directly to agents. Paul Copplestone points out an obvious yet widely neglected practice: upgrading error messages. At a developer tools dinner the night before, Copplestone was stunned that more teams were not doing this. Standard developer tooling historically throws unhelpful HTTP 500 errors or vague warnings that force humans to go Google the problem. To make products agent-friendly, Supabase injects explicit instructions and documentation directly into its error messages so that autonomous models can self-heal without getting stuck or switching providers.
“Inside the error messages, you are literally telling them how to fix this error or to go and read some docs to fix the error,” Copplestone explains. Winning agents requires a two-step approach: first, getting selected by the model; second, ensuring that when the model inevitably encounters an obstacle, it has the exact tools to remedy the failure immediately. As Copplestone puts it, “guaranteed they'll get stuck at some point. You just want to give them the tools to remedy.”
- Supabase has built internal eval suites alongside a public eval website to measure how different models perform at building software and specifically writing PostgreSQL queries.
- Engineering resources at Supabase have shifted heavily away from raw feature building toward creating comprehensive test suites for specific agentic use cases.
[32:16](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=1936s) Gbrain, OpenClaw, and the Limits of LLM Working Memory
Gary Tan details how he built Gbrain on top of Supabase after evolving his earlier project, Gary’s List—an agentic newsroom that used retrieval-augmented generation (RAG) to ingest policy papers and newspaper articles for synthesis. In his early Ruby on Rails setup, Tan treated each LLM call like a "Foxconn factory for agents," operating under the belief that every call was prohibitively expensive and dangerous. Shifting to an OpenClaw-based approach felt completely different, like moving to an Esalen-style paradigm where you trust that the AI is smart, not out to hurt you, and simply needs data and capabilities.
Even with massive context windows, Tan argues that large language models still face fundamental context limits. While a 1-million-token context window is equivalent to roughly three Harry Potter books—far exceeding human working memory of roughly seven items plus or minus two—keeping the *exact right* three Harry Potter books in context across an entire personal or organizational history is an unsolved retrieval problem. Tan holds over half a million markdown files containing records of every interaction and communication he has ever had, comprising 30 to 40 gigabytes of unstructured data. Giving agents access to this knowledge without context saturation required building an intermediate layer:
“At any given moment, the agent might need like two pages or something. It's a retrieval problem and so at that point, you know, at many—I think it's like 30, 40 gigabytes—you need pgvector, you need Postgres, you can do graph databases very easily in SQL, and so that's what Gbrain is.”
```mermaid
flowchart TD
accTitle: Gbrain Knowledge Retrieval Architecture
accDescr: Flow diagram showing unstructured markdown data indexing into Supabase pgvector and PostgreSQL graph representations to feed relevant context into an AI agent.
[35:40](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2140s) Autonomous Loops, Dynamic Indexes, and Continuous Evals
Tan explains how he bootstrapped Gbrain's data structures by spinning up Claude Code, using tools like Exa to search, download, and diarize cutting-edge AI research papers on RAG, graph databases, and retrieval strategies. Once summarized, the AI designed and built the architecture itself. Copplestone adds that at another dinner discussing the future of databases, attendees envisioned databases fundamentally as retrieval mechanisms where autonomous agents run in continuous optimization loops. If a query against a complex dataset takes 10 seconds, an agent can spin up, craft a specialized index or dynamic data structure, and bring that retrieval time down under a second.
Tan confirms that dynamic retrieval is inevitable with high-capability code generation and shares how he operationalizes it today:
- Production traces from OpenClaw are extracted into a benchmark repository called `Gbrain-evals`, covering 40 distinct evaluation categories across retrieval efficiency, cost efficiency, and latency.
- An autonomous research agent loops continuously on these benchmarks; any change that improves evaluation metrics is merged directly into master and enabled by default.
- Any failed experiment requires the agent to write a markdown post-mortem documenting why it failed before archiving it into the evaluation suite.
- Using Cappy’s "Captains" framework (analogous to Grok bots), one continuous agent generates new evaluation categories while another runs daily automated research loops against the category suite to improve system performance.
Tan describes this setup as a running, primitive form of recursive self-improvement (RSI) targeted at personal retrieval that could easily generalize to broader software stacks.
[38:42](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2322s) Steve Yegge, Evals, and Late-Night Coding by Voice
The conversation turns to whether the everyday builder of tomorrow will actually need to understand evals, trace frameworks, and retrieval pipelines, or if those mechanics will simply be abstracted away. Paul Copplestone admits that the industry is still in its infancy, with engineers currently improvising solutions in open source and discovering the fundamental building blocks in real time. “I think we're literally coming up with the primitives on how to use this stuff right now,” he explains, recalling how earlier in the year he read Steve Yegge’s essays on software factories and struggled to parse them until he cobbled together a functional system of his own. The hosts contrast this hands-on, eval-heavy workflow with the vision previously shared on the show by Boris Cherny, who imagined a future where users merely talk to Claude casually like a friend, completely oblivious to evals or lower-level plumbing, while the model sorts out the implementation behind the scenes.
Paul illustrates just how close that conversational paradigm already is through a personal experiment. Having previously hoarded the domain name `openusd.dev` because of the OpenUSD 3D file format, he suddenly felt compelled to launch something when Stripe and Visa announced their own Open USD stablecoin initiatives. Lacking the bandwidth to manually construct a site, he directed Claude Code to assemble a full developer ecosystem site. The interaction transitioned from typing at his desk to speaking to the model over a phone call as he was turning in for the night. As Paul sheepishly jokes, calling his AI agent in bed “sounds sus, but I promise I'm just coding with it.” While lying down, he critiqued the site’s information architecture, noting that the ecosystem links did not map neatly to use cases, and asked the model for recommendations. Within twenty seconds of his approval, Claude rewired the links, hooked up the SEO scaffolding, and updated the live site.
Paul emphasizes that while his engineering background naturally helps him prompt effectively, he deliberately constrains himself when building so he can experience what non-technical users will encounter next year. His goal is to dogfood Supabase from the vantage point of a newcomer to guarantee that the underlying database platform delivers a smooth developer experience even when piloted by an autonomous agent. While Boris Cherny's dream of fully automated generation works once knowledge is baked into model weights, Paul points out that for new or rapidly evolving libraries, providing just a modest amount of markdown documentation or light prompting remains essential for keeping models on track.
- **OpenUSD domain pivot**: Paul originally registered `openusd.dev` for the 3D graphics file format, but repurposed it overnight when payments giants made headlines with stablecoin initiatives under the same name.
- **Voice-driven development**: Refactoring information architecture and SEO links took just 20 seconds via a conversational phone call while heading to bed.
- **Simulating "normie" developers**: Paul intentionally avoids pointing AI models directly to GitHub repos or using heavy engineering jargon so he can stress-test how Supabase holds up for non-traditional builders.
---
[41:50](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2510s) Parabolic Capabilities, Non-Technical Founders, and the Death of the Series A Badge
The hosts reflect on the surreal societal inflection point emerging around recursive self-improvement and AI research loops. Capabilities inside coding environments like Claude Code and Codex are accelerating parabolically, yet the supply of people who possess the domain knowledge, taste, and instinct to direct these models remains essentially flat. Society is encountering an unstoppable force meeting an immovable object: the machines can build almost anything, but very few people know what is actually worth building. Paul remains distinctly optimistic rather than defensive or paranoid. Having spent previous chapters of his entrepreneurial career building software around blue-collar workers, he views accessible AI agents as an engine for widespread entrepreneurship that can liberate everyday people from grueling work routines. “I can see this future where actually there is going to be so much more entrepreneurship and it's actually quite a fulfilling lifestyle for a lot of people,” he remarks, looking forward to what 2027 will bring if the current pace holds steady.
```mermaid
flowchart TD
accTitle: Startup Scaling Models
accDescr: Comparison between the traditional startup model requiring massive venture capital and the modern AI-assisted lean team structure.
subgraph Traditional["Traditional Venture Model"]
T1["Raise $100M VC"] --> T2["Hire 100+ Employees"]
T2 --> T3["Reach $30M ARR with Low Margins"]
end
subgraph Modern["Modern AI-Native Model"]
M1["Small Seed / Bootstrapped"] --> M2["Lean Team of 10-15 Builders"]
M2 --> M3["$10M-$50M ARR ($2M ARR / Head)"]
M3 --> M4["Highly Profitable / No Series A Needed"]
end
```
This structural shift is already rattling the venture ecosystem, especially within vertical SaaS. The hosts note that enterprise founders generating between $5 million and $10 million in annual recurring revenue—metrics that historically guaranteed an easy Series A term sheet nine to twelve months ago—are suddenly hitting a wall with venture capitalists who are hesitant to fund vertical software. Yet the irony is that these same startups no longer require venture capital. By leveraging modern AI leverage, lean teams of ten to fifteen people can realistically reach $20 million, $30 million, or even $50 million in ARR. At $2 million in ARR per employee with 50% margins, each team member is effectively clearing $1 million a year in profit.
In YC office hours, founders often treat missing out on a Series A as a crushing disappointment, failing to realize their independence is an immense operational victory. The hosts point out that in previous eras, founders were forced to raise $100 million just to hire the armies of engineers and support staff needed to reach $30 million in revenue. Paul agrees, observing how startup culture conditioned founders to treat institutional fundraising rounds as status symbols: “There's a real thing in startups like the badge.” Looking at the current landscape from the helm of a scaled company, he admits he is almost envious of the modern founders who bypass the venture treadmill altogether to build highly lucrative, self-sustaining businesses.
- **Venture fundraising disconnect**: $5M to $10M ARR in vertical SaaS no longer guarantees a Series A, even though that milestone once made funding virtually automatic.
- **Extreme lean-team leverage**: Small teams of 10 to 15 individuals can now sustain $10M to $50M in ARR by substituting AI leverage for headcount.
- **Profitability over prestige**: The traditional vanity metric of raising nine-figure venture rounds to chase growth is giving way to high-margin, cash-flow-positive independence.
---
[45:35](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2735s) The Lindy Effect, Avoiding Corporate Stagnation, and Riding Waves Through Dogfooding
Asked how Supabase has managed to navigate multiple disruptive hype cycles—from early Postgres developer tools to vibe coding and autonomous agents—Paul credits his peace of mind to the Lindy effect. Foundational primitives outlast trends, and databases have proven their staying power across half a century of technological upheaval. “Databases have been around for 50 years. I think they'll be around for another 50 years,” he asserts, noting that when you dedicate your entire life to building a company, anchoring it in an evergreen category is essential because databases will still be required on the other side of the AI transition.
Beyond betting on durable primitives, survival requires rapid, ego-free adaptability. Paul observes that many beloved developer tooling companies follow a predictable, tragic arc: they capture developer adoration early on, only to move upmarket into enterprise contracts, become corporate and rigid, and eventually stagnate as they lose touch with frontline builders. To counteract this drift, Paul studies companies like Stripe, whose founders remain personally invested in cutting-edge development workflows. Supabase protects this adaptability by leaving slack capacity in their engineering schedules so they can experiment, integrate with emerging AI platforms, and take collaborative risks.
Much of that agility stems from an aggressive internal dogfooding culture. For Paul, the fastest way to discover friction is to encounter it firsthand when trying to build new products with Supabase's own stack: “There's no better feedback than you getting stuck on your own tooling.” While many joint ecosystem initiatives and experimental features turn out to be dead ends, keeping the organization nimble enough to launch those bets ensures that whenever a true breakthrough wave emerges, Supabase is already positioned to ride it.
- **The Lindy principle**: Betting a career on Postgres and databases offers structural resilience because data persistence remains non-negotiable regardless of how code is generated.
- **The enterprise stagnation trap**: Dev tool startups frequently lose developer love when pivoting upmarket; staying relevant requires constant focus on how the next generation actually builds software.
- **Strategic organizational slack**: Supabase deliberately preserves internal team capacity to partner with AI tooling ecosystems and test experimental workflows, knowing that while many will fail, the winners create major growth waves.
## Notable quotes
> [45:35](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2735s) There's no better feedback than you getting stuck on your own tooling. — Paul Copplestone
> [45:35](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2735s) Databases have been around for 50 years. I think they'll be around for another 50 years — Paul Copplestone
> [00:00](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=0s) I certainly think that it'll be the case that everyone in the world with access to AI will become a builder of some sort. — Paul Copplestone
> [41:50](https://www.youtube.com/watch?v=vl7HiMdGfjo&t=2510s) I can see this future where actually there is going to be so much more entrepreneurship and it's actually quite a fulfilling lifestyle for a lot of people — Paul Copplestone
## Mentioned
Paul Copplestone, Harj Taggar, Garry Tan, Boris Cherny, Steve Yegge, Supabase, Y Combinator, PostgreSQL, Claude Code, Codex, Claude, Airtable, PostgREST, Turso, SQLite, AWS, Amazon RDS, MongoDB, MongoDB Atlas, Heroku, Parse, Firebase, Stripe, Bolt, Lovable, Blacksmith, Depot, Ubicloud, Gbrain, OpenClaw, pgvector, Exa, Cappy, Dot, Mint, Monarch, Visa
## Video description
In this episode of the Lightcone, the hosts sit down with Paul Copplestone, co-founder and CEO of Supabase. Since starting in the YC summer batch of 2020, the company has exploded to 13 million users and over 50 million databases under management. Supabase is now positioning for a future where everyone can write their own software, billions have access to personal databases and agents are driving much of the demand.
Apply to Y Combinator: https://www.ycombinator.com/apply
Work at a startup: https://www.ycombinator.com/jobs
Chapters:
00:00 Intro
01:18 Growth and 4x Revenue
02:35 Three Eras of Supabase
04:34 “Builders” vs. Traditional Devs
08:42 Personalized Apps
12:12 Personal Databases & Data Ownership
15:56 Scaling to Billions
17:58 AI Adoption At Supabase
19:58 Lessons Learned Along The Way
27:29 Building For Personal Agents, Dogfooding
30:01 Agent-First Design and Evals
38:42 The Future Of Coding
42:36 Opening Up More Entrepreneurship + Outro
Supabase co-founder and CEO Paul Copplestone argues that the proliferation of autonomous coding agents is transforming ordinary individuals into builders, turning personal and lightweight databases into essential infrastructure for agents rather than just enterprise backends.
Agent-Driven Adoption and the Code-First Pivot (0:00)
The rapid adoption of autonomous coding agents like Claude Code and Codex has reshaped platform usage at Supabase, where approximately 70% of new activity is now driven by AI agents rather than manual human interactions. Over a 12-month period, total signups surged from 3 million to 13 million, databases under management expanded from 8 million to nearly 50 million, and weekly database creations exceeded 1 million, alongside 4x annual revenue growth pacing. Copplestone notes that while developer platforms previously prioritized graphical dashboards or REST APIs, agents fundamentally require terminal CLIs, scripts, and code-first environments.
To accommodate agent workflows, developer platforms must cater to model mechanics rather than traditional human UX. For example, generic HTTP 500 error messages cause autonomous agents to fail or stall; Supabase addressed this by embedding explicit instructions and documentation references directly inside error outputs so models can self-heal without human intervention. Supabase also maintains open-source core utilities like PostgREST, which Copplestone claims gives agents the transparency needed to inspect underlying codebases and fix unexpected execution failures, while satisfying enterprise security demands.
Hyper-Personalized Software and Independent System of Record
Collapsing software development friction allows individuals to assemble hyper-niche or single-user applications that would never justify institutional venture funding. Examples highlighted by Copplestone and podcast hosts include a 50-year-old Brazilian taxi driver who programmed a local ride-hailing application directly from his phone, and YC partner Harj Taggar constructing a custom "Control Tower" system that unified email triage, health metrics, and personal finance categorization by matching bank transaction logs against personal notes and contact histories.
Beyond single-use applications, owning an independent database serves as a defense against lock-in from proprietary AI agents. Keeping health, financial, and personal relationship data stored inside an open schema like PostgreSQL allows users to hot-swap frontier models and agents without losing historical context. A unified database also permits cross-domain agent correlations—such as contextualizing an unexpected change in health metrics against recent travel recorded on a calendar—that siloed commercial applications cannot replicate.
Dual Architecture: Bridging SQLite and PostgreSQL (15:56)
Projecting agent adoption to consumer scale presents severe infrastructure constraints. If a platform like ChatGPT—with an estimated 1.2 billion weekly active users—saw each user deploy just one database per month, infrastructure systems would need to handle billions of monthly deployments. Copplestone emphasizes that provisioning full-scale PostgreSQL cloud instances for lightweight toy apps or personal agents is economically and operationally impractical.
To balance rapid low-overhead prototyping with long-term retention, Supabase acquired Turso to power its "Supabase Spark" tier. The architecture combines lightweight, low-footprint SQLite mechanics for hobbyist micro-workloads with multi-petabyte PostgreSQL clusters (Multigres) for scaling enterprises. Copplestone relates this strategy to AWS, noting that roughly 40% of AWS revenue comes from startups that adopted the platform on day one and grew, avoiding painful database migrations later by maintaining a unified migration path from prototype to enterprise tier.
Internal AI Velocity and the Shifting Startup Model (17:58)
Engineering workflows within Supabase have evolved alongside external agent usage. Copplestone reported that within six months, the proportion of company engineers generating at least 80% of their code with AI tools jumped from 10% to 60% without any top-down corporate mandate. Because high-volume AI code generation increases the surface area for software bugs, development teams have shifted their primary focus away from manual line-by-line coding toward automated verification, CI pipelines, and continuous benchmark evaluation suites.
This shift in coding productivity is also altering early-stage startup economics. The podcast hosts observe that domain experts who lack classical computer science training can now build operational products without hiring large engineering teams. Consequently, lean startups of 10 to 15 people can realistically achieve $10 million to $50 million in annual recurring revenue at $2 million ARR per employee, reducing their reliance on institutional Series A venture rounds and challenging the traditional requirement of raising large sums of capital merely to hire engineering headcount.
While Copplestone relies on the half-century Lindy effect of databases to guarantee long-term demand across AI paradigm shifts, questions remain over how non-technical users will manage complex retrieval dynamics, schema migrations, and evaluation frameworks as personal data archives grow.
精炼阅读摘要
Supabase 联合创始人兼 CEO Paul Copplestone 与 Y Combinator 合伙人指出,随着 AI 编程智能体将代码开发彻底平民化,数据库正从单纯的软件后端演变为个人与 Agent 沉淀上下文的通用基础设施,推动软件构建范式向极简团队与去中心化所有权转移。
智能体驱动平台业务呈爆发式重构 (0:00)
在 Y Combinator 旗下的 Lightcone 播客中,Paul Copplestone 透露,YC 传统的“创造人们想要的东西”这一信条正演化为“创造智能体想要的东西”。截至 2026 年,Supabase 平台上约 70% 的新增活跃均由自主运行的 AI Agent 产生,而非人类直接点击。在过去 12 个月内,其平台注册用户从约 300 万激增至 1300 万,管理的数据库总量从 800 万增长至接近 5000 万,每周开辟新数据库超过 100 万个,年度营收增速达到 4 倍。传统软件开发者不仅在加速构建,没有计算机科学背景的非技术群体也在大举涌入,且下游的激活、留存及付费转化指标反常地全面提升。
面向智能体自愈重塑开发工具底层 (2:35)
Supabase 的产品形态经历了三代演进:早期是以表格界面为核心的仪表盘模式,随后转向以 REST 和客户端类库为核心的 API 模式,当前则全面转向面向终端与脚本的 Code-First 及命令行(CLI)模式。由于大模型驱动的编码工具(如 Claude Code 和 Codex)更倾向于操作终端代码而非图形界面,这一架构调整使其成为诸多前沿模型的默认数据层。开源不仅使企业便于审计代码安全,还让智能体在遭遇报错时能直接审查底层逻辑以实现自愈。针对 Agent 易在通用报错中卡死的问题,Supabase 将具体的修复指令和文档说明直接注入报错信息中,并建立了公开与内部评测集以量化模型执行 SQL 的能力。
个人数据主权与专用控制台兴起 (8:42)
随着编程门槛瓦解,软件构建逐渐从依赖风险投资转向长尾、超本地化及个人专属应用。例如巴西一位 50 岁的出租车司机完全通过手机为所在城市开发并上线了一款打车软件;YC 总裁兼首席执行官 Garry Tan 构建的 Gbrain 则通过 pgvector 与 SQL 图谱管理着个人数十吉字节的非结构化历史数据;合伙人 Harj Taggar 打造的个人管理系统“Control Tower”则直接实现了个人财务与健康管理的高精度跨域关联。Copplestone 与主持团队强调,将个人记忆、日常事务与 CRM 数据保存在独立数据库中,能有效防止个人上下文被单一专有大模型绑定,用户由此可以在自有基础设施之上随时无缝切换不同底层模型。
从原型到 PB 级的双端扩展架构 (15:56)
若全球数十亿生成式 AI 用户均开始创建微型数据库,基础设施提供方每月可能需要调度高达 10 亿量级的数据库实例,传统重型托管模式在经济上难以为继。为此,Supabase 收购了兼容 SQLite 与 PostgreSQL 的 Turso,推出轻量级层级“Supabase Spark”,使用户能以低开销启动微型原型;同时通过 Multigres 架构向上支撑数 PB 级的企业集群,从而实现“从原型到 PB 级”的平滑扩展。在公司内部,无强制管理规定的情况下,写代码依赖 AI 超过 80% 的工程师比例在 6 个月内从 10% 跃升至 60%,开发重心由此从手工编写特性转向依靠自动化测试和 CI 校验系统代码的稳健性。
精简组织模型与技术持久性法则 (41:50)
模型能力的指数级跃升使得构建成本大幅降低,创业门槛正从“如何构建”彻底转移到“构建什么”。播客指出,仅有 10 至 15 名员工的极简 AI 原生团队现在能够凭借极高的人效支撑 1000 万至 5000 万美元的 ARR,这颠覆了以往依靠巨额 A 轮融资和庞大研发队伍堆砌规模的传统风投路径。面对频繁更迭的技术炒作周期,Copplestone 认为关系型数据库符合林迪效应(Lindy effect)——作为存在了 50 年的基础要素,数据持久化层仍将跨越这一轮 AI 变革而长期存续;团队则需通过激进的内部产品试用(Dogfooding)保持敏捷,避免传统开发者工具公司走向大企业市场后常见的官僚与停滞陷阱。
尽管 AI 极大地解放了个体软件构建能力,但面向数十亿数据库并发调度的新架构仍在探索中,行业关于未来是由非技术用户直接进行高层对话、还是仍需掌握数据检索与评估流水线的底层原理,目前仍未形成最终定论。
Source quotes
[45:35] Paul Copplestone: There's no better feedback than you getting stuck on your own tooling.
[45:35] Paul Copplestone: Databases have been around for 50 years. I think they'll be around for another 50 years
[0:00] Paul Copplestone: I certainly think that it'll be the case that everyone in the world with access to AI will become a builder of some sort.
[41:50] Paul Copplestone: I can see this future where actually there is going to be so much more entrepreneurship and it's actually quite a fulfilling lifestyle for a lot of people
Original transcript
[0:00] I'm genuinely excited about what the
[0:03] future could be for a lot of people. The
[0:05] thing that I really love about Superbase
[0:07] is that like I see a lot of
[0:08] entrepreneurship um because of the
[0:11] platform. I certainly think that it'll
[0:13] be the case that everyone in the world
[0:16] with access to AI will become a builder
[0:18] of some sort. Like you can build
[0:19] anything, you can customize it. You want
[0:21] to make tweaks to some app, some UI,
[0:24] then you don't have to be beholden to to
[0:26] someone. I'm pretty pumped about 2027
[0:29] actually.
[0:37] Welcome back to another episode of the
[0:38] light cone. Today we're joined by Paul
[0:40] Coppstone, co-founder and CEO of
[0:42] Superbase, the open-source Postgress
[0:44] backend that's become the default
[0:46] database inside tools like Cloud Code
[0:48] and Codeex. Superbase now has 13 million
[0:51] users and it's spinning up over a
[0:53] million databases a week. Paul, welcome
[0:56] to the Lite Cone.
[0:57] >> Thanks for having me.
[0:58] >> So, to start off, uh, you know, famously
[1:01] YC gives you a t-shirt on the first day
[1:03] of YC that says, "Make something people
[1:04] want." But increasingly, all of us are
[1:07] realizing it's make something agents
[1:09] want. And your company really
[1:12] exemplifies that. You know, something
[1:13] like 70% of the new activity is from
[1:16] agents. Isn't that crazy?
[1:18] >> Yeah, it's wild. It's wild. I think like
[1:21] this year especially what we've seen in
[1:24] terms of the numbers the inflection is
[1:26] just a huge shift towards agents
[1:29] >> just so we can understand just how much
[1:30] you guys have grown cuz it's kind of
[1:32] mindboggling. Um yeah like what are the
[1:33] numbers you care about and where were
[1:35] you like this time last year and where
[1:38] are you now? I think this time last
[1:40] year, so yeah, we're 13 million signups
[1:42] now. Probably 12 months back, we would
[1:45] have been around three perhaps. Um, this
[1:48] year, like revenue will grow, 4x. Um,
[1:53] we've got trying to think what
[1:55] >> you got like a million databases being
[1:56] created per week at the moment.
[1:59] >> Yeah. Yeah. Yeah.
[2:00] >> What was it this time last year? I think
[2:01] actually if um databases under
[2:04] management now are approaching 50
[2:06] million and this time last year it was 8
[2:08] million. So it's just a huge huge
[2:11] inflection.
[2:12] >> What's been driving that?
[2:14] >> First people are building with abandoned
[2:17] software engineers.
[2:19] Second I think that there are a lot more
[2:22] builders coming online. So what was
[2:24] traditionally uh someone with a software
[2:26] engineering background is now uh it's
[2:30] now becoming possible for non-engineers
[2:32] to actually build things on top of
[2:34] superbase.
[2:35] >> So this is a really big shift. Uh what
[2:37] have you guys actually done to
[2:38] facilitate or encourage this shift from
[2:42] you know obviously software engineers
[2:43] are going to keep choosing superbase but
[2:46] you know how do you get the agents to
[2:48] come over in the first place? Yeah, we
[2:50] largely have seen like three chapters in
[2:53] Superbase. We started as a dashboard
[2:55] company, then we went to an API company,
[2:57] and now we're very much a code first
[3:00] company. So, we try to have the
[3:03] modalities that the agents really want
[3:06] to build with, which is code first. They
[3:07] really want to use CLI most of the time.
[3:10] The other thing is just being chosen as
[3:13] a default uh in the LLMs which I think
[3:16] we were a huge beneficiary of our of our
[3:19] um the timing of which we started to
[3:21] become a default choice for databases.
[3:24] >> How much do you think being open source
[3:26] played a role in it too cuz the agents
[3:28] love open source things?
[3:29] >> You know it's hard to know the
[3:30] counterfactual but I think it was
[3:31] critical. I mean everything that we do
[3:34] is open source and it seems to have been
[3:36] a a huge benefit to us and we do it in a
[3:40] very open- sourcy way like we tried to
[3:42] support existing tools. It's not just
[3:44] superbased tools we we support like
[3:47] Postgress is a very um famous tool for
[3:51] the Postgress Ecosystem and we help to
[3:54] maintain that. So we kind of got sprawl
[3:56] across many communities. I would guess
[3:58] that the agents actually really like
[3:59] open source because when something goes
[4:01] wrong, it can just look at the source.
[4:03] >> Yeah.
[4:03] >> Yeah. I mean, I noticed the agents
[4:05] really like feeling powerful and they
[4:07] love data and uh there's nothing more
[4:09] frustrating than hitting a brick wall
[4:11] and then you don't know what's going on
[4:13] and you can't fix it. I think it's going
[4:15] to be increasingly important as well
[4:17] because now with you know security being
[4:21] so important I think a lot of the say
[4:24] enterprises are going to want to inspect
[4:26] the source code to know that it's secure
[4:29] and if you've got closed source code
[4:31] then you probably won't want to adopt
[4:33] them as a vendor.
[4:34] >> Is developer even still sort of the the
[4:37] core user that you're going after or how
[4:40] you know how do you think about it now
[4:41] in 2026? Yeah, I think that the world
[4:44] where we're moving and at least what
[4:46] we're seeing this year is like um kind
[4:49] of builders builders are coming online
[4:51] and it's like a crazy amount of people
[4:54] coming online. The crazy thing about
[4:56] this year is usually when you're um like
[4:59] our top of funnel, our signups are
[5:01] accelerating. And usually when this
[5:03] happens, you see a lot of the other
[5:06] numbers start to decline, activation,
[5:08] conversion. But actually this year, all
[5:10] of them are kind of going up and to the
[5:12] right, which is a bit insane just
[5:15] because the models are getting so good
[5:17] at building. And we're starting to see
[5:19] people who traditionally wouldn't have a
[5:22] software engineering background able to
[5:23] come and and build things.
[5:25] >> That's the distinction is like builder
[5:26] as in they might not be actually
[5:29] software engineers. They might just be
[5:31] someone who needs to build a thing and
[5:34] they're just, you know, popping open
[5:35] cloud code and then it turns out files
[5:38] only get you so far.
[5:40] >> Yeah. And in some ways like this
[5:42] category of people have all these pent
[5:44] up ideas that they could never convince
[5:46] a software engineer to like help them
[5:48] build and now they don't have to
[5:49] convince anyone. They've got all these
[5:51] ideas that they're churning out.
[5:53] Software engineers still make up a huge
[5:55] portion but the rate of the growth of
[5:57] the builder segment is is pretty pretty
[6:00] big. Also like I don't know where the
[6:03] ceiling is on this one. Like I I
[6:07] remember our early investors were saying
[6:09] ah PLG product like growth is going to
[6:12] tap out at this revenue and you'll have
[6:14] to start moving into this segment of the
[6:16] market and there just appears to be no
[6:19] ceiling so far and I I can't see where
[6:22] it stops.
[6:23] >> I mean that was basically true like two
[6:25] years ago or one year ago but definitely
[6:27] not true this year.
[6:28] >> Yeah. I was just talking to someone
[6:30] actually this last weekend if it's the
[6:31] builder category. It's like a a fintech
[6:34] founder just exited his company of like
[6:36] over a billion dollars and um he's
[6:39] always been sort of product adjacent
[6:40] like studying math at like as an
[6:41] undergrad and sort of like kind of could
[6:44] pull together some Ruby scripts but like
[6:46] always need an engineer to like build
[6:47] the software and now side projects he's
[6:50] just building his own stuff and he has
[6:52] all the knowledge from how to build a
[6:53] fintech company so he can actually build
[6:54] pretty sophisticated just like for his
[6:56] own personal finances like balance
[6:58] sheets and tracking software and knows
[6:59] how to like integrate in with banks and
[7:01] he's wring all the integrations from
[7:03] scratch and it's just like the kind of
[7:04] software that would never have been
[7:06] built um even 2 years ago. These are the
[7:09] perfect type of builder as well because
[7:11] like developers like me I have very like
[7:14] developer focused ideas and things that
[7:16] I want to build but then you've got all
[7:18] these domain experts and they know
[7:20] exactly the niches of oh this is an
[7:22] unsolved problem in my niche and so
[7:24] they're actually able now to like dig
[7:27] right into those niches without having
[7:29] to convince someone else to join them. I
[7:31] think you guys were talking about this,
[7:32] weren't you in NYC, like the profile
[7:35] shifting even from from who you're
[7:37] bringing into the cohort. I think that
[7:39] if you look at the sort of era of what
[7:42] 2022 2025 there's sort of this real
[7:46] shift thinking like well AI is coming
[7:48] and suddenly um having software
[7:51] engineering as uh you know core you know
[7:54] you need a technical co-founder no
[7:55] matter what that was like a a mega idea
[7:59] that you know really came to the four at
[8:01] YC during that time period. is always
[8:03] sort of true, but like sort of doubled
[8:05] down on that. Uh and then really in the
[8:07] last year, we sort of said actually
[8:10] yeah, builders like we're starting to
[8:12] see people who are able to like I mean
[8:14] the much harder thing to do is to know
[8:17] what to build. You know, being able to
[8:19] build is something that anyone can sort
[8:21] of have on tap now. And that's actually
[8:23] a really cool thing. Like can you
[8:25] imagine all the things that never would
[8:27] have built exactly for what you said?
[8:29] It's like oh we know that people would
[8:30] buy this. We know that there's a problem
[8:32] here, but at the margins, those people
[8:36] couldn't convince an engineer to work
[8:38] [laughter] on it.
[8:39] >> Do you have some examples, Paul, of like
[8:41] apps that people have built on
[8:43] Superbase,
[8:45] maybe just for themselves, that are the
[8:46] kinds of things that would have never
[8:47] been built before?
[8:49] >> Well, one kind of cool example was at
[8:52] our conference. We had the conference
[8:53] here and afterwards this guy from Brazil
[8:56] came up to me and he's built an entire
[8:59] taxi app uh from his phone and it's um
[9:05] kind of like a a little mini Uber for
[9:07] his local market and I just thought he's
[9:10] a taxi driver himself. I don't actually
[9:12] know why he built it, but the fact that
[9:14] he could build it and he came up
[9:16] extremely grateful and that he could do
[9:18] this and also like with the type of
[9:21] energy he's he was like 50 years old or
[9:24] something like that, but he had the
[9:25] energy of a like teenager building
[9:28] suddenly, which I think is kind of cool
[9:30] because now it's kind of getting to that
[9:32] stage where I I think it's a little bit
[9:36] there's so much uncertainty around like
[9:39] what is the future of work going to look
[9:41] like but in this category of builders
[9:43] there's that excitement of the future
[9:45] and that's really what I love about
[9:47] superbates it's like something that
[9:49] people can come in and those who are
[9:51] uncertain now are discovering this skill
[9:53] set and these opportunities where
[9:55] previously they were just blue collar
[9:57] workers these type of profile
[9:59] >> hard you've been building some of your
[10:00] own personal software recently you talk
[10:02] about what you've been cooking up
[10:03] >> it's just grown yeah it's sort of like
[10:04] the end of one stuff but it's just grown
[10:06] out of um getting really addicted to
[10:10] open claw actually like maybe 6 months
[10:12] ago now I'm embarrassed I said it I said
[10:14] like there was going to be no UIs and it
[10:16] was all just going to be like chat
[10:17] through my open claw but it turns out
[10:19] actually and I also was really
[10:20] determined not to use a database for a
[10:22] long time I just wanted everything to be
[10:23] in markdown um but yeah it turns out
[10:26] actually you hit a point where like a
[10:27] database is useful and you do need UI so
[10:30] I've just been building that over the
[10:31] last couple of weeks in particular and
[10:33] so it's like um I mean I call it control
[10:35] tower but it's just like sort of every
[10:38] section of my life like I have like a UI
[10:40] I to like triage all my emails so I
[10:41] don't need to read my inbox. Um,
[10:44] finances, tracking like spending,
[10:46] health, like both like tracks my weights
[10:48] and my workouts and everything is all in
[10:50] like one place. But I like the magic of
[10:53] it is sometimes it's a mindboggling
[10:55] thought actually is like I think about
[10:56] like the finance section of like my one
[10:58] app for myself is better I think is at
[11:01] least feature parity to mint or monarch
[11:03] or all of these things but in some ways
[11:04] actually better because you can start
[11:06] doing really personalized context like
[11:09] it can figure out what a transaction is
[11:11] by looking up in my like the name in my
[11:13] Gbrain to figure out who that person is.
[11:15] Oh, like you know that's like and and
[11:17] and categorize it correctly. And that
[11:19] was like a whole company like several
[11:20] startups just doing personal finance and
[11:22] then you just like build it for yourself
[11:23] and I don't need it to work for anyone
[11:25] else or like have anyone else's opinion
[11:28] on it. It's just like kind of like my
[11:29] thing is like it's kind of awesome. We
[11:31] see a lot of that one like where it's
[11:33] finance and health are basically the two
[11:36] like ones where you want your own data.
[11:38] So we see a lot of people doing that and
[11:41] syncing all the devices to a single
[11:43] database is kind of a magic skill. And
[11:46] then you can like prompt it to like
[11:48] build these correlations across.
[11:50] >> It's the correlations that are really
[11:51] bad. Like again like if you just take
[11:52] the health example, it's like yeah all
[11:53] of that data is in like my two base
[11:55] database but then it also has access to
[11:56] my calendar so it knows things like it's
[11:58] like oh like your weight I know your
[12:00] weight went up recently but like you
[12:02] were traveling so that's okay like you
[12:04] can just like get back on track um next
[12:07] week. And it just has like this context
[12:08] that's really valuable. I also found as
[12:11] I started to use the personal agents
[12:13] like I'm getting a little bit paranoid
[12:15] that I'm putting all of like all of the
[12:19] um like routines and everything and the
[12:21] CRM is becoming like um boxed into one
[12:24] agent. And so now I'm slowly extracting
[12:26] it out into one so that if I want to
[12:28] attach different agents on top then I
[12:31] know that like I can use any any agent.
[12:33] So the CRM is another really critical
[12:36] one. Yeah, that's why you guys are so
[12:37] valuable is like actually like it's like
[12:39] the it's sort of like the store of
[12:41] record. to the the the database is
[12:44] actually the thing that's valuable. Like
[12:45] you don't you want to own your own
[12:46] database and then build all the
[12:48] applications or agents on top of it
[12:50] versus having that all in like someone
[12:52] else's database.
[12:54] >> Which is a totally wild idea like if you
[12:55] just think about the history of
[12:57] databases used to be the case that like
[12:59] the world had only a relatively small
[13:01] number of very large databases run by
[13:04] like large companies. And I remember
[13:06] like when Subbase got started, you kind
[13:08] of had this idea that they should be
[13:09] like really easy for everyone to like
[13:11] make a database. And it almost like
[13:14] didn't make sense at the time why so
[13:16] many people would want to do that
[13:18] because unless you can write code, what
[13:19] can you do with a database? And there's
[13:21] not just not that many people who can
[13:22] actually like write code and build a
[13:24] personal CRM like that. Like it's just
[13:25] like too much work for most people preI.
[13:28] >> Like another example actually where
[13:29] super is really valuable for me is like
[13:31] the other section I have is just like a
[13:32] file upload. Sounds very simple, but
[13:34] like any file I can sort of either
[13:36] forward via email or just like dump it
[13:38] in this UI and then like my agent like
[13:41] figures out what that is and how it's
[13:43] relevant to my life and like what to do
[13:45] with it. Um, but that's all being stored
[13:47] on Superbase. And so yeah, in general,
[13:48] it's just like Superbase is actually
[13:50] going to end up having like all of the
[13:53] like data about my life in a single
[13:55] place and like I would I would never
[13:57] have thought about wanting a personal
[13:59] database like a year ago because it
[14:01] wouldn't have made any sense. But now I
[14:03] like that's actually like the most
[14:04] valuable thing.
[14:05] >> Yeah. You have like an S3 compatible
[14:06] superbase files thing and all my stuff
[14:08] is in that.
[14:09] >> Oh, really? Nice. Yeah. Yeah. Yeah.
[14:11] >> It's default in Gbrain. [laughter]
[14:14] >> Great. Thank you.
[14:15] >> Do you think this is the future, Paul,
[14:17] where like basically everyone in the
[14:19] world, not every developer, every person
[14:21] will have a superbase database that has
[14:25] stuff about their life in it, their
[14:26] health, their finances, their
[14:28] relationships.
[14:29] >> Yeah, we'd love that. I mean I I
[14:31] certainly think that it'll be the case
[14:33] that everyone in the world with access
[14:35] to AI will become a builder of some
[14:37] sort. Like you can build anything, you
[14:39] can customize it. You want to make
[14:40] tweaks to some app, some UI, then you
[14:44] don't have to be beholden to to someone.
[14:46] Of course, like we think of ourselves as
[14:48] an index company. We when we came into
[14:50] YC, we just focused on YC companies. We
[14:54] wanted to win all YC customers and like
[14:57] now that was because we knew that we had
[15:00] to be there on day one when businesses
[15:02] were getting started. The mission didn't
[15:04] change just the aperture has like
[15:07] increased significantly. Now as more
[15:09] builders come online we know that we
[15:11] need to service them which is actually a
[15:13] whole different problem to solve but
[15:16] kind of an exciting one.
[15:17] >> Significantly meaning like 10 millionx.
[15:21] >> Yeah. Like so what we launch now a
[15:24] million databases every single week but
[15:27] I mean if you do some basic arithmetic
[15:29] let's say with chat GPD I think they
[15:31] said they've got 1.2 billion weekly
[15:34] active users and let's say all of them
[15:36] want to launch something every month
[15:39] that's 1.2 two billion databases a
[15:42] month. And so that's like the scale that
[15:44] we're moving towards architectures that
[15:46] we need to have so that we can actually
[15:48] cater for for that scale which is
[15:51] something that has never had to happen
[15:53] before on the database database realm.
[15:56] >> Can you even do that with Postgress? Are
[15:58] you going to have to build your own
[15:59] database engine to scale to 1 billion
[16:01] new databases per week?
[16:03] >> I think yeah. Well, if we could
[16:05] negotiate better with AWS, then maybe we
[16:08] could.
[16:09] Turns out that uh everyone wants
[16:11] computers at the moment and and actually
[16:13] like I don't know if you need like such
[16:18] a Ferrari for a lot of these workloads
[16:20] and we made an acquisition recently
[16:22] terso they've got an architecture that's
[16:26] um compatible with postgress and
[16:28] actually it's compatible with SQLite as
[16:30] well. I think SQLite's a phenomenal
[16:32] database and so we'll provide this tier
[16:35] which we call superbase spark which is
[16:37] basically for for these getting started
[16:39] workloads the idea won't be the same you
[16:41] get started with the same experience you
[16:44] can scale up to pabytes so our tag lines
[16:46] kind of prototype to pabytes
[16:49] and we as a company need to make sure
[16:51] that we can provide for everyone and if
[16:54] they do scale up and their business
[16:56] keeps growing then we make sure that
[16:58] they have a great time. Yeah, that's
[16:59] something I was curious about how you
[17:01] think um about this actually is like the
[17:03] classic sort of software company. you
[17:05] start with, you know, maybe early stage
[17:08] startups like in a YC batch and then you
[17:10] sort of have one eye towards the
[17:11] enterprise and I feel like especially if
[17:12] you're a database company like preAI the
[17:15] convential wisdom as well like you want
[17:17] to be Oracle so you got to get to the
[17:18] enterprise as quickly as you can because
[17:20] that's where all the money is and so you
[17:21] start building out like enterprise
[17:23] features you sort of leaning into SQL
[17:25] light is sort of going the opposite
[17:27] direction like how do you how do you
[17:29] think about it like are you sort of
[17:30] looking both ways?
[17:31] >> Yeah. Yeah, we're having to do both
[17:33] which is like incredibly difficult. Um,
[17:36] basically we've got two products that
[17:37] cater on the two ends. So multigresses
[17:40] scale up to pabytes and then terso scale
[17:42] down to like these prototyping and
[17:45] SQLite type workloads. So trying to do
[17:48] this uh at the rate of growth with like
[17:50] having to employ more people. It's just
[17:53] even with AI is becoming or has been a
[17:56] real challenge but a fun one. So you ran
[17:59] a poll recently uh where people went
[18:02] from 10% of your engineers were writing
[18:05] 80% of their code with uh the coding
[18:09] agents and then that number recently got
[18:11] up to 60% in a matter of 6 months like
[18:15] how did that happen? What's happening?
[18:17] Like you know where is this going from
[18:19] here?
[18:20] >> So we don't have an AI policy
[18:22] internally. we just let people do
[18:24] whatever they whatever they want and we
[18:26] give them access to to whatever tools
[18:28] they they want to use. And I think now
[18:32] it's just that they're convinced that
[18:33] the models can do so much better better
[18:36] work and so much more. So the adoption
[18:39] has been crazy and yeah the the things
[18:43] that they're building internally are not
[18:45] just viodated type stuff. They're pretty
[18:47] intense. Um, and as we're like shifting
[18:51] into this uh like AI coded realm, like
[18:54] just the amount of testing that we're
[18:56] doing and the tools that we're adopting
[18:58] for testing is being pretty useful to
[19:00] make sure that they actually know that
[19:02] the end result is going to be good.
[19:04] Yeah, we're seeing that across YC the YC
[19:07] startups like uh Blacksmith Depot, Ubie
[19:09] Cloud, like they're all vertical because
[19:11] everyone's doing CI. Yeah.
[19:13] >> And the number of tests that you have
[19:15] for just like three
[19:16] >> reptile for like review.
[19:18] >> So that's pretty wild honestly to see.
[19:19] Was it like a partic like it's just the
[19:21] models are good enough now and like you
[19:23] just people spend enough time where
[19:24] they're like oh actually this is quite
[19:26] good
[19:26] >> and people need to be convinced
[19:28] especially uh engineers like I mean they
[19:31] might not
[19:32] >> at the start of the year I've thought
[19:34] that it was very good and the models
[19:37] have gotten better but also they're
[19:39] starting to see oh actually you can
[19:40] achieve some great things with with
[19:42] these models and all the stuff with
[19:45] Navia Stokes and all these stuff like
[19:47] convincing the market that actually yeah
[19:50] we can break new ground here. So I think
[19:53] that's the world that we're moving
[19:54] towards and now people are convinced
[19:55] that this is the way that it's going to
[19:57] be.
[19:58] >> You've seen Superbase like through three
[20:01] eras. First kind of like a dashboard
[20:02] company um built in a 100 days during YC
[20:07] then the API company and then now it's
[20:10] you know sort of this agent you know
[20:12] make something agents want sort of
[20:14] moment. Uh was there like one or two
[20:16] things like in each era that really jump
[20:18] out at you like oh that was the thing
[20:20] that made us in that moment?
[20:22] >> I think like those shifts happened. So
[20:24] the first one actually Yeah. I think
[20:26] you're saying like why would a database
[20:29] um company exist when we came into YC?
[20:32] We actually
[20:32] >> it seemed like such a contrarian idea at
[20:34] the time actually.
[20:35] >> Yeah. Yeah. Yeah. I think like we saw
[20:37] how hard it was to use a database even
[20:39] for developers and so that dashboard
[20:42] first was like oh let's build a UI that
[20:46] looks like air table on top of Postgress
[20:48] because I actually loved air table as
[20:50] well. I was like wouldn't it be cool if
[20:52] that was just a Postgress database on
[20:54] the back end. So um that one was just
[20:57] seeing that even software engineers
[20:59] struggled. And then like when we moved
[21:01] to AI, I think we talked about this on
[21:03] the other podcast, the AI uh API um
[21:07] shift was because we had someone
[21:08] integrating with us and they were like,
[21:11] "Oh, we want to launch lots of
[21:12] databases. We need an API to do all of
[21:15] this." And that was like 2021 maybe. And
[21:19] it turns out that was exactly the right
[21:21] move for 2024 when the likes of Bolt and
[21:24] Lovable and all of these people started
[21:26] building on top of us. Then this year I
[21:29] just saw that actually no one's coming
[21:32] to the dashboard like no one [laughter]
[21:34] no one visits dashboards anymore. So um
[21:37] how are agents going to build? In this
[21:40] one I just kind of put out a product
[21:42] memo to the team that said it has to be
[21:45] code first get native. Superbase just
[21:47] has to shift to to code first. So if it
[21:50] exists on the dashboard, it basically
[21:52] has to work in lock step in code
[21:54] infrastructure as code essentially and
[21:57] we rearchitected a lot of the CLI and
[22:00] everything to work in sandboxes in code.
[22:03] >> Were you guys maybe too far back but
[22:04] were you ever inspired by par another
[22:06] white company?
[22:07] >> Yeah. Yeah. Yeah. Par and Firebase. I I
[22:10] liked both of those companies and it's
[22:13] funny these waves, right? because they
[22:15] did the back end and Firebase acquired
[22:18] by Google, pars by Meta,
[22:22] but
[22:23] in some ways I think they like blazed
[22:26] the trail for us to come along and
[22:28] actually have a legitimate database
[22:30] business because in 2014 it would have
[22:32] been ridiculous not to use RDS for your
[22:35] for your database. Then they came along,
[22:38] came along, u started moving
[22:40] to Atlas and a lot of these database
[22:42] companies kind of showed that you don't
[22:45] need to just use one of the three
[22:47] hyperscalers. You can actually have a
[22:49] legitimate database company and um so
[22:53] that that timing was crucial for us.
[22:55] >> Yeah, past sort of forgotten that it was
[22:57] like actually a really well-built
[22:58] product. They launched like just when I
[23:00] was building iPhone apps for the first
[23:02] time and it was like quite nice to
[23:04] switch to like a nice restful API that I
[23:06] was trying to deal with.
[23:07] >> These shifts always happen with like
[23:09] inflection points, right? So at that
[23:11] point there were two things that
[23:13] happened in the market. Somehow MongoDB
[23:16] convinced everyone that NoSQL was
[23:18] supposed to be like an amazing uh way to
[23:21] store your data. And um the second was
[23:24] mobile. And so, you know, we're
[23:26] fortunate that we had a couple of these
[23:28] waves as well and now we're right in the
[23:32] thick of it. And
[23:33] >> yeah, I mean, this [clears throat] is
[23:33] what I was asking about sort of like how
[23:34] you think about the enterprise versus
[23:36] early cuz I think I mean you go even
[23:38] further back. This is sort of like
[23:39] Heroku was the first where it's like hey
[23:41] like just start with like the best
[23:42] developer experience and then scale up.
[23:45] But it is actually can be quite hard to
[23:47] like scale up with people and I think
[23:49] like you know Heroku sort of I don't
[23:51] could quite bridge that gap um to how do
[23:53] you keep people on you like as the apps
[23:56] get bigger and and need to be more
[23:58] performant etc etc but like historically
[24:00] every company's had to figure that out
[24:02] and like I know you guys are looking
[24:03] that way but you might not have to like
[24:04] honestly if the like the the market for
[24:06] just owning like I don't know call it 0
[24:09] to 10 whatever like keeps expanding at
[24:12] this rate it's going to be huge. Yeah.
[24:15] Well, we want it all. So, [laughter]
[24:17] >> so we might not have to, but uh we'll
[24:19] definitely do it. And like kudos to
[24:22] Heroku. I think they popularized
[24:25] Postgress, but at the time Postgress was
[24:28] pretty uh it was still pretty nent and
[24:31] it still got some scaling um limitations
[24:34] and so yeah, we've had to wrap Postgress
[24:37] and some tooling that will allow it to
[24:39] scale indefinitely. But I mean I guess a
[24:41] better analogy for you guys is more like
[24:42] AWS was able to actually like get people
[24:44] early and like scale and so do yeah like
[24:48] what are the lessons maybe like how do
[24:49] you think about making sure you can
[24:51] scale
[24:52] >> infinitely? the lesson I think that they
[24:55] I heard a stat and was telling me I
[24:57] might get it wrong so fact check me but
[24:59] something like 40% of AWS's revenue
[25:02] comes from like startups that started on
[25:05] them and then scaled up and like that's
[25:08] the category that we want you know like
[25:11] we know that to convince people to
[25:13] migrate to from one database provider to
[25:16] another is near impossible and so we
[25:19] just want to be there on day one make
[25:21] sure that they have a great time and and
[25:22] make sure that they actually don't want
[25:24] to leave.
[25:24] >> The same business model to strip. I
[25:25] mean, it's like basically the best
[25:26] business model on earth if you can get
[25:27] it. But you get them on day one and then
[25:29] like scale with like the fastest growing
[25:31] companies in the world infinitely
[25:33] >> and you just do that for a generation
[25:35] and you become a generational business.
[25:37] That's pretty much it. Yeah. It's hard
[25:39] for us because
[25:40] >> what does day one look like? That's
[25:42] rapidly shape changing. So in the past
[25:45] day one for me was always like why see
[25:47] customers and now day one is becoming
[25:49] like okay everyone's a builder what are
[25:52] they going to use what are the
[25:53] modalities what how are they going to
[25:56] choose their databases these are tricky
[25:58] questions next batch is now taking
[26:02] applications got a startup in you apply
[26:04] at y combinator.com/apply
[26:07] it's never too early and filling out the
[26:09] app will level up your idea okay back to
[26:12] the video it's kind a different customer
[26:14] segment like like initially when you
[26:17] started like there was not an individual
[26:19] market for databases like the idea of a
[26:21] database company being a direct to
[26:22] consumer business would have just like
[26:25] sounded like a syntax error.
[26:26] >> Yes.
[26:26] >> Um but now you actually have two
[26:29] segments. You have the like early stage
[26:30] companies that that that has this
[26:32] powerful stripe business model, but
[26:34] you're also like selling directly to
[26:36] consumers or to their agents perhaps.
[26:38] >> Yes. Yes. And those use cases presumably
[26:41] will not scale the way startups will,
[26:44] but they might just like continue to use
[26:46] you for like for the rest of their lives
[26:47] because you're powering the app that
[26:49] like runs their personal finance
[26:50] software or their taxi cab company or
[26:53] something like that.
[26:54] >> And as their lives grow and they
[26:56] accumulate information, that is
[26:58] basically an index of our our own
[27:00] growth, you know. So they just store
[27:02] more. People are collecting more data.
[27:04] this kind of proumer market is
[27:06] essentially a good growth vector for us.
[27:09] I guess do you think about the personal
[27:10] agent world in that through that
[27:13] perspective then if sort of coding
[27:15] agents want superbase it's very clear
[27:17] like do you think about the next phase
[27:18] as being assuming we all have personal
[27:21] databases like do you need to do
[27:23] anything to make sure that it's easy for
[27:25] personal agents to talk to you is that
[27:27] any different or is it basically the
[27:28] same thing? Yeah, I'm very bullish now
[27:31] on personal agents after a week of my EA
[27:33] being away and uh me learning exactly
[27:36] what they can do. And now I'm just kind
[27:39] of obsessed with the idea of building
[27:41] for personal agents. And it's true that
[27:45] I I said to our company like we're code
[27:48] first. Um like we're building for humans
[27:50] that are doing code first, but actually
[27:52] we're doing it for agents. Those humans
[27:54] pretty soon won't actually be
[27:55] interacting. So like the way I've been
[27:57] building is I'm using dots. Um I just
[28:01] sit on a phone call with it all the time
[28:03] and I'm chatting to it and saying oh can
[28:06] you make these changes and my my kind of
[28:09] heristic to make sure I'm building or
[28:10] dog fooding correctly is that I just
[28:12] don't look at the code and I don't allow
[28:15] myself ever to check the architecture
[28:18] except when I want to check that it's
[28:20] actually building things correctly. But
[28:21] when I'm making these changes I just
[28:23] want to talk to it and see what it can
[28:24] change. So,
[28:26] >> one of us. [laughter]
[28:29] >> It's crazy as well. Like, it's doing
[28:31] some phenomenal stuff that I just it it
[28:34] feels like something out of a sci-fi
[28:36] movie from like 2 years ago, but now
[28:40] like I'm having so many of these moments
[28:42] that I'm just mind blown. If you had
[28:44] shown someone this 6 months ago, they
[28:47] would have just thought it was
[28:48] impossible.
[28:48] >> Yeah. you I was at um your Subbase
[28:51] select conference a couple weeks ago
[28:53] which is awesome conference by the way
[28:54] and I had this like kind of crazy
[28:56] thought. I was sitting there and you
[28:58] were talking about all these awesome new
[28:59] features that Superbase was putting out
[29:02] and I was like you know if I was
[29:05] building an app on Superbase maybe I
[29:07] wouldn't even care to understand all
[29:09] these awesome features myself. I want to
[29:10] like send my agent to Superbase Select
[29:12] to like listen to all the awesome new
[29:15] features and figure out how to integrate
[29:16] them into my codebase. Oh, that's wild.
[29:18] A truly virtual conference. We should do
[29:21] that. A conference just for agents.
[29:22] >> For agents. A conference [laughter] for
[29:24] agents.
[29:24] >> They all turn up live.
[29:26] >> Live. They [clears throat] can like talk
[29:27] to each other, exchange tips on like,
[29:29] you know, Facebook live.
[29:31] >> Wow. Well, you can bridge it. You can
[29:32] sort of airdrop like the markdown file
[29:34] for everyone, but you have to be there
[29:36] in like the the audience to get it.
[29:38] >> We'll call it the artifactory.
[29:40] [laughter]
[29:42] >> Oh man, I quite like that. We talked
[29:44] about before this like there's just a
[29:46] bunch of things that you've been doing
[29:47] that like really make agents like you
[29:50] better like error messages you know you
[29:53] know what was that key insight and like
[29:55] are there a bunch of other things that
[29:56] you're doing that kind of obvious on the
[29:58] one hand on the other hand like nobody's
[30:00] doing yet? Yeah. So like the error
[30:02] messages. Yeah. I was at a dev tool
[30:04] center last night and I was surprised
[30:05] that this wasn't so obvious, but we
[30:10] really dug into our error messages so
[30:12] that you can take a use case like oh I
[30:14] want to build an application and
[30:16] generally like developer error messages
[30:18] are like 500 um something basic and you
[30:22] just know there's a problem but now you
[30:24] actually want the agents to like remedy
[30:26] themselves. So inside the error
[30:28] messages, you are literally telling them
[30:30] how to fix this error or to go and read
[30:33] some docs to fix the error. So a lot of
[30:35] it is just picking your use case and
[30:38] just trying to do these loops on
[30:40] improving your own error messages so
[30:42] that you can oneshot basically anything
[30:44] that you want.
[30:45] >> Yeah, that makes sense. Basically, you
[30:47] know, if you're being used by an agent,
[30:50] the agent will encounter an error
[30:52] message. In the past, a human would have
[30:53] to go Google that and do a bunch of
[30:55] stuff, but here you can just say, oh,
[30:57] like you're just, you know, out of
[30:59] nodes, so you should probably go do
[31:02] this.
[31:02] >> Yeah, cuz there's like two stages to
[31:04] winning the agents. The first is being
[31:06] picked by the model, and then the second
[31:09] is like if they get stuck, you don't
[31:11] want them to switch away. So, guaranteed
[31:14] they'll get stuck uh at some point. You
[31:16] just want to give them the tools to to
[31:18] remedy. So, uh, it's not actually that
[31:21] complicated. They're smart enough now
[31:23] that they can figure out a lot of stuff,
[31:24] but you do have to re-engineer a lot of
[31:27] what previously was just for humans and
[31:29] developers for agents.
[31:31] >> Do you test your project, your product
[31:33] for agents? Like, do you have agents
[31:34] like try to use Superbase and then like
[31:36] report all the places where they had
[31:38] trouble?
[31:39] >> Yeah. Yeah. Yeah. All the different
[31:40] models. We've got an eval um website
[31:43] where we see which models are building
[31:44] the best and we got our own eval um
[31:48] suite internally. We eval as well which
[31:51] ones are best just with Postgress. So
[31:52] that's interesting for the industry and
[31:54] build skills around it so that they can
[31:56] adopt them and actually develop with
[31:58] Postgress. So yeah, it's a lot of
[32:01] testing and in fact pretty much now a
[32:03] lot of our engineering effort is going
[32:06] into like testing specific use cases
[32:09] rather than the building. We want to
[32:11] think through how people are building
[32:14] and build suites around that.
[32:16] >> Gary, when you built Gbrain, you built
[32:17] it on top of Superbase. Can you talk
[32:19] about like how did you decide to build
[32:20] it on top of Superbase? What was it like
[32:23] for you to be a a user? Yeah, I guess I
[32:25] mean Gbrain was like a distillation of a
[32:29] bunch of stuff I wrote like I first
[32:31] worked on Gary's list which was like
[32:32] agentic it was like an agentic newsroom
[32:35] and I had to build up like basically a
[32:38] research system for rag and for like
[32:40] policy and papers and it would like read
[32:43] every newspaper article about a given
[32:45] topic and then try to synthesize um and
[32:49] then I took that and then distilled it
[32:50] into uh open- source retrieval for
[32:54] openclaw
[32:55] cuz the idea was like, okay, I had it in
[32:57] Rails and that was kind of like a Foxcon
[33:00] factory for agents. It's like I treated
[33:03] every LLM call as very expensive and
[33:06] incredibly dangerous. And then when I
[33:09] saw OpenClaw, it was this, you know, it
[33:11] was kind of like Eselin. It was just
[33:12] like a very different way for uh you
[33:15] know, you to work with AI cuz then it's
[33:17] like, oh, the AI is smart. uh it's not
[33:19] trying to hurt you and then you should
[33:21] just let it like do stuff and you should
[33:24] just give it data and capabilities. And
[33:26] so I recognized a million tokens is
[33:30] actually an incredible working memory.
[33:31] Like most human beings only have like
[33:34] seven plus or minus two things that they
[33:36] can keep in their head. Whereas like a
[33:38] million tokens is like basically uh like
[33:41] three Harry Potter books. But then even
[33:43] that is like a little bit limiting for
[33:45] the agents. Like keeping the correct
[33:48] three Harry Potter books in your context
[33:50] at any given time is a real challenge.
[33:52] So it felt like there was this thing in
[33:54] between for a company brain or like my
[33:57] personal stuff. It's like you I have
[33:59] half a million markdown files on like
[34:01] every communication I've ever had. And
[34:04] so this thing really does have context
[34:06] on me and everything that I care about.
[34:08] Uh but then at any given moment like the
[34:11] agent it might need like two pages or
[34:13] something. it's a retrieval problem and
[34:16] so uh at that point you know at many I
[34:19] think it's like 30 40 gigabytes you need
[34:22] PG vector you need Postgress you know
[34:25] you can do graph databases very easily
[34:27] in SQL and so that's what Gbrain is it's
[34:30] like you know rag retrieval um plus like
[34:34] a a graph database that creates like
[34:37] structure out of unstructured data
[34:39] >> and so it's like dynamic schemas like a
[34:41] little bit like what I remember uh
[34:42] Palanteer was back in the day.
[34:45] >> And then, you know, the entire idea is
[34:47] that agents are much more powerful when
[34:50] um there's sort of this intermediate
[34:52] thing where the agent can just say like
[34:54] this is what I'm looking for and it'll
[34:56] traverse the graph. It'll do all of the
[34:59] uh you know uh vector search and it'll
[35:01] come back and say like here here's a
[35:03] report and like load this into context.
[35:05] And so that's what Gbrain is. And then
[35:07] Superbase was just like very
[35:09] straightforward. It's like I need I need
[35:11] hosted Postgress and I need it to be
[35:13] able to support like a 50 or 100 gig or
[35:16] 300 gigabyte you know database uh corpus
[35:19] really fast and uh it's been great like
[35:22] you know the autoscaling works really
[35:23] really well and now the funniest thing
[35:25] is like with browser use like I use a
[35:28] side browser now for browser use and
[35:30] it's like oh yeah like open clock can go
[35:32] into superbase and you know use the
[35:34] database or the new APIs you made and it
[35:37] just like managed it itself it can like
[35:38] self-manage
[35:40] Were you having to prompt it to like
[35:42] figure out the data structures like
[35:44] graphs or like rag or anything like that
[35:47] or
[35:47] >> uh I mean what's funny is like I I
[35:49] remember going into cloud code and just
[35:51] saying like use Exa and download and
[35:55] diorize uh every paper you can find in
[35:58] AI research. Um, today I could use like
[36:01] alpha signal or something, but it's like
[36:03] go and find every piece of research
[36:05] about rag and graph databases and like
[36:08] you know text retrieval and then
[36:11] summarize it for like my use case which
[36:13] is like how do I help an agent get
[36:15] access to this stuff and then after it
[36:17] did that it's like oh okay well here's
[36:20] here's how we're going to do it. Yeah, I
[36:21] was at a dinner the other night on like
[36:23] the future of databases and one idea was
[36:25] like databases essentially are like a
[36:27] retrieval mechanism for for data and you
[36:30] know you can put indexes so that they'll
[36:32] search across the data in certain
[36:34] format. So a graph or or rag and then
[36:36] one of them which was super interesting
[36:38] was just like putting an agent on a loop
[36:40] to create the perfect data structure for
[36:43] the search. Like if you're searching
[36:45] this data set this many times and it's
[36:48] taking 10 seconds, then why don't you
[36:50] just put an agent on a loop to create a
[36:52] new type of index or like find the best
[36:55] index for returning that in less than a
[36:58] second.
[36:58] >> I mean dynamic retrieval is pretty
[37:00] clearly going to happen the second you
[37:01] have really really smart codegen.
[37:03] >> Yeah.
[37:04] >> So I mean for now I mean I use it for
[37:07] open claw. So then uh I use my
[37:09] production instance and then the traces
[37:11] from that um I extracted out like a eval
[37:15] data set and then I have a separate um
[37:17] repo called Gbrain evals and it's got 40
[37:20] different categories of like specific
[37:23] types of uh retrieval uh retrieval
[37:25] efficiency like cost efficiency latency
[37:29] and then uh the cool thing about eval is
[37:31] then you can just tell the agent like
[37:33] loop you know just auto research and
[37:35] loop and anything that uh improves your
[37:38] stats on this eval like ship it into
[37:40] master on by default. Yeah.
[37:42] >> And anything that you tried that didn't
[37:44] work, write a markdown file that you
[37:46] know explains why you think it didn't
[37:47] work and then file it away in Gbrain
[37:49] evals. I use Cappy. There's a you know
[37:51] Cappy has this concept of uh captains
[37:54] which is kind of like similar to
[37:55] Grockbots bots. And so you can just give
[37:57] it a context. And so I have one that is
[38:00] always going that's like come up with
[38:02] new categories. And I have another
[38:04] captain that's uh always going that's
[38:06] like go through all the categories in
[38:08] evals and auto research and every single
[38:11] day try to find a way to improve our
[38:13] scores on our own internal evals
[38:16] >> and that's just going all the time. It's
[38:18] a very very primitive uh version of RSI
[38:21] for like a particular use case but I
[38:23] guess if you like go up one level of
[38:25] abstraction you know you could do that
[38:27] you know not for uh my use case which is
[38:31] from for openclaw or something like it
[38:32] could just be for generically like
[38:34] anyone's retrieval use case like the
[38:37] only thing that changes is like the use
[38:39] case and uh the traces and the data set.
[38:42] You obviously know about eval and you
[38:44] can improve your software because you're
[38:46] like wrapping this framework around it.
[38:48] Like do you think that in the future
[38:51] builders will have to actually know
[38:52] about these type of things or
[38:54] >> maybe not? I mean honestly I feel like
[38:55] we're so early that you know I'm just
[38:58] messing around and you know I like doing
[39:00] it in open source and someone else you
[39:02] know I hope someone looks at that and
[39:03] says like oh I can apply that you know
[39:05] like we're I think we're literally
[39:06] coming up with the primitives on how to
[39:09] use this stuff right now. Yeah. I mean,
[39:10] I remember earlier in the year, you
[39:12] know, reading about Steve Yaggi's uh
[39:14] software factories and things like that
[39:16] and then not being able to totally
[39:18] figure it out and it's like, oh, no, no,
[39:20] I feel like now I've cobbled together
[39:22] something that works for me at least.
[39:24] >> Yeah. Yeah. When we had Boris Turney
[39:26] here, um his vision of the future of
[39:30] coding was more like you just talk to
[39:32] Claude like a friend and you don't have
[39:33] to know about eval
[39:36] all this all this stuff and like Claude
[39:38] just like figures out how to build the
[39:40] thing that you have in your mind.
[39:41] >> I've got this domain name openusd.dev
[39:44] dev and it's because there's actually a
[39:47] file format called open USD and I
[39:48] collect domain names and then suddenly
[39:51] >> stripe and visa and everyone announced
[39:53] open USD and I was like oh I better put
[39:55] this domain to use now but I never had
[39:58] time to to use it so I was chatting to
[40:01] the dot and it's like developed this
[40:03] like developer site with the ecosystem
[40:06] and everything and I was just chatting
[40:09] to it on my computer and then like as I
[40:11] was winding down my day I called it on
[40:13] my phone like as I'm getting to bed
[40:15] which sounds sus but I'm [laughter] I
[40:17] promise I'm just just coding with it and
[40:20] I was like saying I don't like the
[40:22] information architecture of how like the
[40:24] ecosystem links to the the use cases can
[40:28] you make some suggestions and it did and
[40:30] I said okay yeah implement them and then
[40:32] 20 seconds later it said ah yeah okay
[40:34] I've done it do you want to refresh and
[40:36] I refreshed the site and it was really
[40:38] well written and everything was linking
[40:40] together and it's hooked up the SEO type
[40:43] stuff and so I haven't done all the
[40:46] classic stuff that I'd have to do
[40:48] traditionally. I've just been chatting
[40:50] to it and it really felt like one of
[40:52] those moments where I was I I sort of
[40:55] saw a glimpse of the future.
[40:56] >> I mean you can do that because you know
[40:58] what you want to build.
[40:59] >> That's the thing. Yeah. So like I
[41:01] obviously have a background in
[41:03] engineering so I kind of know how to
[41:05] prompt it but I'm trying to not say
[41:08] anything. I'm trying not to like point
[41:11] it towards GitHub or anything like that.
[41:13] And I'm trying to code like a like a
[41:15] normie or someone will do next year so
[41:18] that I know it's basically so I can dog
[41:20] food um Superbase and know that oh is it
[41:23] going to have a good time with Superbase
[41:26] in one year's time. Yeah, it's funny for
[41:28] Boris to say like, "Oh, I I just want it
[41:30] to do it automatically." And like
[41:32] certainly once it's into distribution,
[41:35] like literally the model has it, you
[41:38] know, in its weights, it can do it. But
[41:40] until then, it needs like some markdown
[41:42] or so. You just like a like not even a
[41:45] lot of prompting, like very small
[41:46] amounts of prompting, it can just do it.
[41:49] I we're entering this very strange
[41:51] moment in society I think where like uh
[41:54] it sounds like RSI really is here and
[41:56] it's like going from like the 20% to 80%
[41:59] moment of like AI research is just
[42:02] happening um in sort of these inside
[42:04] these loops inside you know cloud code
[42:06] or codeex or wherever it is and then
[42:09] simultaneous to that like society
[42:12] doesn't really have enough people like
[42:14] you Paul who like know what to build and
[42:17] how to ask it. And so it's like
[42:20] unstoppable force meets immovable object
[42:22] right now. Like the capabilities, the
[42:25] models are like going parabolic and then
[42:28] the number of people who know how to
[42:30] actually have an impact on society with
[42:33] it is like more or less constant.
[42:36] >> Yeah. And want to be kind of excited by
[42:39] it. I I think that's the other thing. I
[42:41] think a lot of people were getting
[42:42] paranoid, but I'm genuinely excited
[42:46] about what the future could be for a lot
[42:48] of people. A lot of my previous startups
[42:50] were focused on like blueco collar
[42:52] workers and like people who I was
[42:55] wrapping tech around a lot of people who
[42:57] just had to work a lot of their life you
[43:00] know and I the thing that I really love
[43:03] about superbase is that it's um like I
[43:07] see a lot of entrepreneurship um because
[43:09] of the platform and so I can see this
[43:13] future where actually there is going to
[43:15] be so much more entrepreneurship and
[43:17] it's actually quite a fulfilling
[43:19] lifestyle for a lot of people. So, I'm
[43:21] pretty pumped about 2027 actually. As
[43:23] long as we can keep this cadence up and
[43:26] avoid a few few crazy events, then then
[43:29] it should be a fun ride for a lot of
[43:31] people.
[43:32] >> We're seeing this moment where vertical
[43:35] SAS founders actually are kind of
[43:36] struggling with raising series A's. uh
[43:39] you know when you're subscale at like
[43:41] you know five to 10 mil ARR even which
[43:44] like historically is a lot of ARR like
[43:46] that's like a guaranteed series A even
[43:48] like 9 or 12 months ago and today it's
[43:52] like uh I don't know people are kind of
[43:54] like not really into it um for vertical
[43:57] like horizontal and AI investments like
[43:59] seems like it's uh totally green light
[44:02] but like vertical SAS people are really
[44:04] struggling but it's also sort of
[44:06] happening right at the moment where you
[44:08] can get to 10 to 15 mil, you know, often
[44:11] 25, 30 mil, 50 mil with like 10 or 15
[44:14] people. And so at that point, like
[44:17] you're very profitable at that point.
[44:19] >> Yeah. Yeah. Yeah. With like if you got
[44:21] 15 people, 2 million AR per head and
[44:24] with 50% margins, you're all making a
[44:26] million million a year. I mean, that's
[44:28] an amazing outcome for for a lot of
[44:30] people.
[44:31] >> Yeah. And simultaneous to that, we just
[44:33] do a lot of office hours with people who
[44:34] do like they got the brass ring and then
[44:37] they're bummed out that they can't raise
[44:38] the series A. And so, you know, many of
[44:42] my office hours there are just like
[44:43] you're probably going to look back on
[44:45] this as a blessing cuz you don't need
[44:47] the money. Like time was you had to
[44:49] raise like a hund00 million to get to
[44:51] like 30 million a year in revenue cuz
[44:53] you just had to hire all these people
[44:55] and now you don't have to do that.
[44:56] >> Yeah. Yeah. There's a real thing in
[44:58] startups like the badge. I I mean it was
[45:00] the same for me like to get funding at
[45:03] the start like feel felt like you know I
[45:05] was achieving something great but
[45:08] actually you know to actually not fund
[45:11] raise now would in my mind be like oh
[45:14] that's achieving something great so like
[45:16] I'm a little bit envious of these
[45:18] companies that that are getting to that
[45:20] point.
[45:20] >> Yeah. So, I don't know. I mean, it's a
[45:22] super changing world, but um your super
[45:24] basease of all the companies has really
[45:26] been able to ride high through every
[45:28] single wave. Um do you have any thoughts
[45:31] for people as they try to emulate what
[45:34] you've done?
[45:35] >> One thing that helps me sleep well at
[45:37] night is that it's kind of the Lindy
[45:40] effect. Databases have been around for
[45:42] 50 years. I'm I think they'll be around
[45:44] for another 50 years. And this is one
[45:46] that at the end of AI no matter what I'm
[45:49] pretty certain they'll be databases. So
[45:51] apart from that whatever you will like
[45:53] uh you got to choose categories that are
[45:55] very durable and if you're going to bet
[45:59] your entire life which is basically what
[46:01] I'm doing you choose the category that
[46:03] you feel is worth investing in. I think
[46:07] the other one is like things are
[46:08] changing so fast. So we don't try to
[46:11] have all the answers as superb base, but
[46:14] we just try to make sure that we're
[46:15] always adapting the fastest. And you
[46:19] know, for me, I've evaluated or like
[46:22] watched a lot of my favorite dev tools.
[46:26] um they kind of start
[46:28] with the developer focus and then they
[46:30] always move up and they become very
[46:32] corporate and they kind of stagnate a
[46:35] lot and they lose that that love. And
[46:38] from our point of view, at least from my
[46:41] point of view, companies like Stripe for
[46:43] example, they have this real like
[46:46] someone like a founder who just cares
[46:48] about like almost focusing on what the
[46:51] new ways of building are. And so if
[46:54] you're like building for this next wave,
[46:57] you just always need to be one eye on
[46:59] the future of what is next, which is a
[47:01] very short timeline now. Things are
[47:04] moving so fast, but um being super
[47:06] adaptable um and making sure you've got
[47:09] capacity within your team to shift very
[47:11] fast. That's the thing that we're that
[47:13] we're focusing on for the next year. are
[47:15] the things that you've learn maybe any
[47:16] specific things you've learned there
[47:18] like because you've had you know maybe
[47:20] had the initial vibe coding inflection
[47:22] point and then the opus 48 inflection
[47:24] point and just codegen like when the
[47:27] next sort of wave hopefully next like
[47:28] many inflection point hit for you but
[47:30] like are there things that you'll you'll
[47:32] do differently to be better prepared for
[47:34] it
[47:34] >> well first of all like dog fooding is
[47:36] one of the most important things at
[47:38] least from our um perspective so I'm
[47:40] always trying these tools with ours to
[47:44] know where are the gaps there's no
[47:45] better feedback than you getting stuck
[47:47] on your own tooling. Um, and then having
[47:50] capacity. So we try to partner with with
[47:53] the the key players in the space and
[47:56] this ecosystem player has been really
[47:57] helpful because they give us feedback on
[47:59] what they're building so that and we try
[48:01] to leave some capacity within the team
[48:03] which is also very difficult but um so
[48:06] that when they have ideas we can we can
[48:08] give it a shot and not a lot of the bets
[48:11] actually win. Even when they seem like
[48:13] we're partnering together to do some new
[48:16] cool thing we actually don't know. They
[48:18] might sound cool and we try them out and
[48:20] they they they kind of flop, but the
[48:23] ones that do work then end up meaning
[48:25] that we ride this awesome wave together.
[48:28] >> That's a great note to end on. Paul,
[48:30] thanks so much, man. We'll see you guys
[48:32] next time.