Software Growth

Dogfooding

Dogfooding (eating your own dog food) means your team uses its own product for real work, so you hit bugs and friction before customers do. Origin, examples, limits and a how-to.

Dogfooding means your own team uses the product you sell, for real work, the way a customer would. The one-line rule: before customers rely on something, you rely on it first, so you hit the bugs and the friction while they are still cheap to fix.

The full phrase is "eating your own dog food". If you build a project management tool, you run your company's projects on it. If you sell invoicing software, you send your own invoices with it. For a small SaaS team it is one of the cheapest sources of product insight there is, and it tells customers you trust what you sell. This guide covers what the phrase means, where it came from, well-documented examples, where dogfooding stops working, how AI companies use it now, and a step-by-step way to do it. For a quick visual round-up of startups using their own tools (Lemlist, Ahrefs, Notion, Figma and Fomo), see our blog post Eat your own SaaS dog food.

What "eat your own dog food" means

To eat your own dog food is to use your own product under the same conditions your customers do. Wikipedia's definition is simply "the practice of using one's own products or services", and it lists two benefits: it works as quality control, and once the product is on the market it shows that the people who build it trust it.

The key word is real. Clicking through a test account is QA. Dogfooding is when your actual work depends on the product, so a bug costs you something. Joel Spolsky called it "the process of actually using your own product".

Some companies dislike the image and use other names. Wikipedia records "drinking our own champagne" (Pegasystems' CIO in 2007), "icecreaming" (Microsoft's CIO in 2009), "eating our own cooking" (IBM's mainframe developers) and the more neutral "self-hosting", where developers run the latest daily build of what they are working on.

Where the term comes from

Nobody knows for certain who said it first, and the stories are worth treating as stories. In a 2006 IEEE Software editorial, Warren Harrison recalled 1970s Alpo dog food ads in which the actor Lorne Greene said he fed Alpo to his own dogs. Another version he remembered was that the president of Kal Kan Pet Food ate a can of his own dog food at shareholder meetings.

In software, the phrase is usually traced to Microsoft. Wikipedia, citing Microsoft's own book Inside Out (2000), says that in 1988 manager Paul Maritz sent Brian Valentine, test manager for Microsoft LAN Manager, an email titled "Eating our own Dogfood", challenging him to increase internal use of the product. The term spread through the company from there. Maritz, by then CEO of VMware, joked about it at VMworld in 2009, telling the audience that coining the phrase was one of his only contributions to IT: "You can read about it on Wikipedia, so it must be true."

The practice is older than the phrase. In February 1980, Apple president Mike Scott sent a memo banning new typewriters, with the goal of having none left at Apple by January 1, 1981. Staff who gave up their typewriters for an Apple II running Apple Writer would get first priority on new systems. His reasoning: "We believe the typewriter is obsolete."

Let's prove it inside before we try and convince our customers.

Mike Scott / Apple internal memo, "Typewriters" (February 1, 1980)

Why it matters for SaaS

Dogfooding matters most when you are small, because it is the shortest feedback loop you have. You don't need to recruit testers, schedule calls or wait for support tickets. Four things happen when your team relies on the product:

  • You find the bugs that stop real work. Spolsky took a build of Fog Creek's CityDesk home about three weeks before it was due to ship and tried to make a real site with it. Menu-by-menu testing had passed, but he hit showstoppers within a minute and logged 45 bugs in a Sunday afternoon of about two hours. He notes that many were inconveniences rather than defects, which is exactly the kind of problem testing misses.
  • You feel friction customers won't tell you about. Most users don't report that a task takes six clicks. They just use the product less. Your team notices because it pays that cost every day.
  • Bad decisions get reversed faster. Spolsky's counterexample is Juno, where he worked earlier: almost everyone used Outlook instead of their own email client. The president insisted on popup ads at six points until he used Juno at home, saw six popups, and asked for two.
  • It is credible. "We run our company on it" is a claim prospects can test. Wikipedia also notes the flip side: the risk of being seen struggling with your own product is one reason some companies keep their dogfooding quiet.

Chances are, it's because the developers of the software don't use it.

Joel Spolsky / What is the Work of Dogs in this Country? (May 5, 2001)

For bootstrapped founders, dogfooding often starts before the company does. 37signals' Getting Real says Basecamp began as a fix for the agency's own problem: it needed a simple way to keep clients updated on projects. Paul Graham's How to Get Startup Ideas (November 2012) makes the same point: the best ideas tend to be "something the founders themselves want". When you are your own first customer, dogfooding is the default.

Dogfooding examples

These are documented by the companies or people involved, or by sources that cite them. They are not marketing claims.

  • Microsoft, Windows NT (1991). According to Wikipedia, citing G. Pascal Zachary's book Show-Stopper!, Dave Cutler insisted in February 1991 that the NT team develop the operating system on machines running NT's daily builds. The early builds crashed often, but breaking the build held up colleagues' work, and that pressure was a strong motivator.
  • Microsoft, Exchange (1993 to 1996). Microsoft's internal email had run on Xenix. During the move to its own Exchange server, the internal test environment was codenamed "Dogfood".
  • Fog Creek, CityDesk (2001). After Spolsky's 45-bug afternoon, he asked everyone on the team to build at least one serious site with the product. Importing a real New York Times page took him a full day, so he wrote an import feature that took about half a minute. A colleague then found about 10 bugs in that feature.
  • 37signals, Basecamp and everything since. In a 2025 episode of the REWORK podcast, Jason Fried and David Heinemeier Hansson explain that every 37signals product is used internally before it ships, and that some products and features never make it past that stage.
  • Slack (2013). Slack started as the chat tool Stewart Butterfield's company, Tiny Speck, built for itself while making the online game Glitch. When it became clear the game wouldn't be profitable, the team turned its internal tool into the product.
  • Perplexity (2024). Co-founder Johnny Ho told Lenny's Newsletter that the product doesn't launch until it gains "internal traction via dogfooding". That works as a release rule: if the team won't use it unprompted, it isn't ready.

Dogfooding AI products and agents

AI products made dogfooding more important, because a demo shows almost nothing. Whether an agent is useful only becomes clear after weeks of real tasks, with real data, at real cost. Here is how teams building them describe it:

  • Anthropic and Claude Code (July 2025). In How Anthropic teams use Claude Code, the company describes engineers, lawyers, marketers and data scientists using it for their own work. It says it learns about new uses from customers, "including our own employees".
  • Google AI and compute costs (May 2026). Vikas Kansal, who leads product for Google AI, writes in Lenny's Newsletter that internal use of the Genie 3 world model showed the compute cost was too high to offer it to every free user. Dogfooding showed the unit economics before launch, as well as the bugs.
  • OpenAI and ChatGPT Sites (October 5, 2026). On How I AI, Claire Vo's show, OpenAI's Kath Korevec explains that she spent over a year building and using Sites internally before the public launch. One of her examples is an incident command site for her own team, connected to live Slack and Notion data.
  • The outside test (October 21, 2026). Claire Vo's review of Claude Duet, titled "Claude Duet is beautiful. I still forgot to use it", shows what internal use can't settle. She calls it the most polished agent launch she has seen. But with her inbox, Slack and sales pipeline to deal with, she argues that a "proactive" agent that never nudges you has a growth problem. Your own team may keep opening your agent out of loyalty. A customer has to choose it over every other tool they have.

During internal dogfooding, we joked that the TPUs were melting on every prompt.

Vikas Kansal / Why SaaS freemium playbooks don't work in AI (May 5, 2026)

For a small SaaS adding AI features, three practical points follow. Run the feature on your own real data before anyone else does. Track what each task costs you in model usage while you do it. And measure whether your team keeps using it once the novelty wears off, before you count on customers doing so.

Limits: you are not always the customer

Venn diagram of your team and your ideal customer. Problems in the overlap, such as showstopper bugs, slow daily workflows, missing basics, and AI cost and latency, are what dogfooding finds. The team-only side holds known workarounds, skipped onboarding and power-user feature requests. The customer-only side holds first-run confusion, their industry's workflow, and their budget and alternatives, which need fresh-account tests, interviews and usage data.
Software Growth. Schematic.

Dogfooding only tests the part of the product where your needs overlap with your customers'. The bigger the gap between your team and your ideal customer profile, the less it tells you.

  • Founders run out of their own itches. Rob Walling makes this point in the startup ideas chapter of his book Idea to Traction, read on episode 854 of Startups for the Rest of Us (October 13, 2026). Scratching your own itch was the popular approach because 37signals used it, and it produced Basecamp, WP Engine and Drip. But at some point founders had to look beyond their own itches and solve problems for other people, in markets they don't work in themselves.
  • Experts don't see beginner problems. Your team knows the workarounds, skips onboarding and never reads the empty states. Wikipedia notes that developers "may have knowledge to make software work that an end user will lack". It also records Microsoft's CIO admitting in 2008 that staff upgraded from betas and so never went through the actual customer experience.
  • It can push you toward feature creep. Internal users ask for features that fit their own workflow. Check demand outside the team before you build them.
  • Some products can't be dogfooded directly. If you build a scheduling tool for dental clinics, nobody on your team books dental patients. Spend time in a clinic, shadow users and run customer development interviews instead.
  • Forced use breeds workarounds. Wikipedia lists the criticisms: dogfooding can start too early, people forced to use a product learn to route around problems or assume someone else reported them, and at the extreme it turns into "not invented here" syndrome.

the world only needs so many project management, bug tracking, and to-do list applications.

Rob Walling / Startups for the Rest of Us, episode 854 (October 13, 2026), from 7:32

The fix is to combine methods. Dogfooding covers the overlap. Fresh-account tests, interviews and usage data cover the rest.

How to dogfood your SaaS

A new feature moves through three rings. First your team uses it for real work every day, with a friction log open. Gate 1: the team uses it without being asked. Then a few friendly customers who fit your ICP get it behind a feature flag. Gate 2: no blockers left open and a fresh-account run is done. Then everyone gets it, announced in the changelog.
Software Growth. Gate 1 adapted from Johnny Ho on how Perplexity launches (Lenny's Newsletter, April 30, 2024). Schematic.
  1. Pick a real workflow. Find one job your company actually does that the product can handle: your own invoices, support inbox, roadmap or onboarding emails. If nothing fits, see the limits section above before you invent one.
  2. Make it the only way. Switch off the old tool for that job. Dogfooding with a fallback turns into "I'll just do it the old way this once".
  3. Open a friction log. Use one shared channel or document where anyone can write "this was annoying" in a sentence, with a screenshot. Low effort matters more than structure.
  4. Ship to yourselves first. Put new features behind a feature flag, turn them on for the team for days or weeks, and only move on when the team uses them without being reminded.
  5. Run a fresh-account session. At least once a release, someone signs up as a new customer on the cheapest plan, with no admin shortcuts and no seed data, and writes down every moment of confusion.
  6. Triage weekly. Remove duplicates, then sort into blockers (can't finish the task), slowdowns (finishes, but painfully) and polish. Fix blockers before anything else ships.
  7. Widen the ring. Give the feature to a few friendly customers who match your ICP, as a beta release, then to everyone with a note in your changelog.

Worked example (fictional)

Bar chart for a fictional two-week dogfooding sprint at Billpond, a 4-person invoicing SaaS. The team logged 52 notes, which reduced to 31 unique issues: 4 blockers, 11 slowdowns and 16 polish items, from 20 hours of real use, or 1.55 issues per hour. A single one-hour fresh-account session found 7 onboarding issues the team never hit.
Software Growth. Fictional example.

Billpond is a made-up four-person invoicing SaaS. For two weeks (10 working days) the team sends its own invoices and chases its own late payments with the product. Each person spends about 30 minutes a day doing real billing work in it.

  • Time invested: 4 people × 0.5 hours × 10 days = 20 hours.
  • Friction log: 52 notes. After removing 21 duplicates (21 ÷ 52 = 40%), 31 unique issues are left.
  • Triage: 4 blockers + 11 slowdowns + 16 polish = 31.
  • Yield: 31 issues ÷ 20 hours = 1.55 unique issues per hour of real use.

None of the 31 issues involve signup or the first invoice, because everyone on the team skipped onboarding years ago. So the founder runs a one-hour fresh-account session on the cheapest plan and finds 7 onboarding issues, a rate of 7 per hour, more than four times the team's rate. That is the limit from the previous section showing up in the numbers. Billpond fixes all 4 blockers this week, schedules the 11 slowdowns, and adds a fresh-account session to every release.

Common mistakes

  • Testing instead of using. A demo account with fake data finds demo bugs. Use real data, real deadlines and real money where you can.
  • Treating team requests as customer demand. Your team is one customer. Check a request with people who match your ICP before you build it.
  • Never seeing the first run. If nobody on the team has signed up from scratch recently, you don't know what your time to value is.
  • Running it as a campaign. A one-week "dogfood week" fades. Make the product the default tool for a real job.
  • Logging without fixing. A friction log that nobody triages teaches the team that reporting is pointless.
  • Calling it validation. Your team liking the product says little about product-market fit. Customers paying and staying does.
  • Read: What is the Work of Dogs in this Country?, Joel Spolsky (2001). The classic short essay: 45 bugs in one afternoon, and why Juno's team never used Juno.
  • Watch: Eat your own dog food, REWORK podcast, 37signals (April 2025). Jason Fried and David Heinemeier Hansson on using everything internally before it ships (from 0:27) and the products that didn't survive it (from 16:48).
  • Listen: How to Find Startup Ideas, Startups for the Rest of Us, episode 854 (October 13, 2026). Rob Walling on scratching your own itch and what to do once your own itches run out (from 10:34).
  • Watch: How the OpenAI team uses ChatGPT Sites daily, How I AI (October 5, 2026). A product lead shows the internal tools her team built on an AI product before it launched (from 1:00).
  • Read: How Anthropic teams use Claude Code, Anthropic (July 24, 2025). A team-by-team account of an AI company using its own agent for real work.
  • Read: Eat your own SaaS dog food, Software Growth. Visual examples from Lemlist, Ahrefs, Notion, Figma and Fomo.

Sources

Back to the SaaS glossary