
In the world of software development, the ultimate testament to a platform's capability is often whether its own creators rely on it for their most critical tasks. For GitLab, the comprehensive DevSecOps platform, this isn't just a talking point—it's a fundamental operational reality. GitLab runs its entire company, develops its vast software, manages its complex infrastructure (including GitLab.com), and fosters its all-remote culture using its own single application. This profound commitment to "eating your own dogfood," or as they often put it, "GitLab on GitLab," is not just a practice; it's a core tenet that shapes the product, drives innovation, and ensures a deep empathy with its global user base.

### The Entire Company Runs on GitLab: A Single Source of Truth

GitLab's vision, as often articulated by CEO Sid Sijbrandij and reflected in their extensive [public handbook](https://handbook.gitlab.com/handbook/), is to provide a single application for the entire software development lifecycle. This vision is most powerfully validated by their own internal adoption. From idea to production, GitLab uses GitLab for:

* **Source Code Management:** The millions of lines of code that constitute GitLab itself are managed in GitLab repositories. Every merge request, every code review, and every version iteration happens within their own platform.
* **Continuous Integration/Continuous Deployment (CI/CD):** GitLab's robust CI/CD capabilities are the engine behind their own development velocity. They use GitLab CI/CD to automatically build, test, package, and deploy GitLab.com and its various components multiple times a day. The [GitLab Handbook page on "Dogfooding CI/CD"](https://handbook.gitlab.com/handbook/engineering/infrastructure/library/ci-cd/) provides a glimpse into how seriously they take this internal proving ground.
* **Plan and Project Management:** All work, from strategic initiatives and new feature development (organized via Epics, Issues, and Iterations) to marketing campaigns and HR projects, is planned, tracked, and managed using GitLab's own planning tools. This ensures that these features are robust and genuinely useful for diverse team workflows.
* **Security (DevSecOps):** GitLab champions a "Shift Left" security approach, and they apply this to their own development by integrating their suite of security scanning tools (SAST, DAST, Dependency Scanning, Secret Detection, etc.) directly into their CI/CD pipelines. This internal use is critical for refining these DevSecOps capabilities.
* **Collaboration and Communication:** As a pioneering all-remote company with team members in over 65 countries, asynchronous communication and transparent collaboration are vital. GitLab (the product) serves as the central hub. Merge requests are key collaboration points, issues track discussions, and the entire company handbook—a sprawling, living document of over 2,000 pages detailing how they operate—is a GitLab project, open to contributions and iterations from all team members. This transparency, a core GitLab value, is enabled by their own platform.
* **Operating GitLab.com:** The SRE (Site Reliability Engineering) and infrastructure teams responsible for the massive GitLab.com SaaS offering use GitLab's monitoring, deployment, and incident management capabilities to keep the service running. This is arguably the most demanding "dogfooding" environment, pushing the platform to its limits in terms of scale and reliability.

### How "GitLab on GitLab" Drives Product Evolution

This deep immersion in their own platform provides a continuous, high-fidelity feedback loop that directly shapes the product:

* **Real-World Problem Solving:** When GitLab's own engineers encounter a bottleneck in their CI/CD pipelines, a missing feature in issue tracking, or a cumbersome aspect of code review, they are experiencing the same pain points their users might. This creates a powerful internal impetus to build solutions that address these real-world needs.
* **User-Centric Design for Developers:** Because GitLab's primary internal users are developers, DevOps engineers, and product managers, the platform naturally evolves to meet the sophisticated demands of technical users who value efficiency, automation, and a comprehensive toolset.
* **Rapid Iteration:** With a monthly release cycle ("every month on the 22nd," as highlighted by [Sid Sijbrandij in an InfoQ interview](https://www.infoq.com/articles/gitlab-sid-interview-sw-development/)), the ability to quickly test and validate new features internally is crucial. "GitLab on GitLab" allows for rapid iteration based on immediate internal feedback.
* **Feature Prioritization:** The features that solve the most significant internal pain points or unlock substantial productivity gains for GitLab's own teams are often strong candidates for broader development and release.
* **AI Integration (GitLab Duo):** As GitLab integrates AI capabilities across the DevSecOps lifecycle with GitLab Duo (e.g., AI-assisted code suggestions, vulnerability explanations, value stream forecasts), its own teams are among the first to utilize and refine these tools in their daily workflows, shaping the future of AI-powered software development from within.

### The All-Remote Context: Shaping a Platform for Distributed Teams

GitLab's all-remote culture is not just a work style; it's a product shaper. Because the entire company collaborates and builds software without a central physical office, the GitLab platform has been inherently designed and optimized for asynchronous workflows, clear communication trails (via issues and merge requests), and transparency. This makes it an exceptionally strong platform for other distributed teams and organizations embracing remote or hybrid work models. Their [All-Remote guide](https://about.gitlab.com/company/all-remote/) is a testament to their expertise, and the platform reflects these ingrained practices.

### Benefits of a Transparent, Dogfooding Culture

The "GitLab on GitLab" approach, coupled with their commitment to transparency (much of their handbook and roadmap are public), yields significant benefits:

* **Authenticity and Trust:** Users and customers can see that GitLab believes in its own product enough to run its entire business on it.
* **High-Quality, Battle-Tested Features:** Features are rigorously tested in a demanding, real-world environment before reaching the wider community.
* **Deep Understanding of User Needs:** GitLab developers have an intrinsic understanding of the challenges and desires of other software development teams.
* **Strong Community Alignment:** By being open about their processes and using their own product, they foster a strong connection with their open-source community.

While the primary users within GitLab are highly technical, the company also focuses on making the platform accessible. However, the depth and breadth of features, as noted in some external analyses like a [SentinelOne article on GitLab CI/CD Security](https://www.sentinelone.com/cybersecurity-101/cloud-security/gitlab-ci-cd-security/), can sometimes present a learning curve for new users—a common challenge for comprehensive platforms that GitLab likely continuously addresses through documentation and UI refinements based on broad feedback.

### Conclusion: The Ultimate DevOps Proving Ground

GitLab's commitment to using its own platform for every facet of its operations is a powerful demonstration of confidence and a critical driver of its innovation. By making its own teams the first and most demanding users, GitLab ensures that its DevSecOps platform is not just a collection of features but a deeply integrated, battle-tested solution designed to meet the real-world challenges of modern software development. The "GitLab on GitLab" philosophy means that when users choose GitLab, they're adopting a platform that is continuously shaped and validated by a global team of experts who don't just build the future of DevOps—they live it every day.

GitLab on GitLab: How the DevOps Platform Builds Itself and a Culture of Iteration


For millions of developers and organizations worldwide, GitHub is the central hub for software development—a place to host code, collaborate on projects, automate workflows, and increasingly, to leverage the power of AI. But GitHub isn't just a provider of these critical tools; it is, by its very nature and culture, its own most avid and demanding user. The principle of "eating your own dogfood," or as it's often put, "GitHub on GitHub," is fundamental to how the platform evolves, ensuring that the tools built for developers are forged in the fires of active, internal development by some of the world's most skilled engineers.

### The Ultimate Proving Ground: Building GitHub with GitHub

From the moment a GitHub engineer starts their day, they are immersed in the GitHub ecosystem. The platform's core functionalities are the bedrock of their own development lifecycle:

* **Repositories, Issues, and Pull Requests:** The very source code for GitHub.com, its myriad features, and its associated services like GitHub Mobile and GitHub Desktop are hosted on GitHub. Internal project management, bug tracking, feature requests, and extensive code reviews all happen within GitHub Issues and Pull Requests. This constant, high-stakes usage by thousands of "Hubbers" (GitHub employees) ensures these core collaborative tools are robust, intuitive, and continuously refined.
* **GitHub Actions for CI/CD and Automation:** GitHub Actions is a powerful workflow automation tool, and GitHub's own teams rely on it extensively for their continuous integration, testing, and deployment (CI/CD) pipelines. As highlighted in [GitHub's own resources](https://digital.ai/catalyst-blog/github-cicd/), Actions helps streamline the development process. By using Actions to build and deploy GitHub itself, engineers gain firsthand experience with its capabilities, identify areas for improvement, and ensure it can handle complex, large-scale automation tasks.
* **GitHub Codespaces for Development Environments:** GitHub Codespaces provides cloud-powered development environments. GitHub's own engineers are increasingly using Codespaces for their development work, allowing them to quickly spin up pre-configured environments, collaborate seamlessly, and ensure consistency across their distributed teams. This internal adoption drives improvements in performance, usability, and feature sets for all Codespaces users.
* **GitHub Copilot: The AI Pair Programmer, Used Internally:** With the advent of GitHub Copilot, an AI pair programmer, GitHub is at the forefront of AI-assisted development. It's a given that GitHub's own developers are among the earliest and most enthusiastic users of Copilot. As stated in the [GitHub Trust Center](https://github.com/trust-center), GitHub has completed Responsible AI Impact Assessments for its AI products. This internal usage and scrutiny are crucial for understanding Copilot's impact on developer productivity, code quality, and for refining its suggestions and capabilities. CEO Thomas Dohmke is a vocal proponent, seeing tools like Copilot as key to empowering a billion developers by 2030 (Source: [Sequoia Capital podcast with Thomas Dohmke](https://www.sequoiacap.com/podcast/training-data-thomas-dohmke/)).

### "Dogfooding" as a Core Engineering Principle

This practice of internal use is not accidental; it's a core part of GitHub's engineering culture. A [GitHub Blog post on engineering architecture](https://github.blog/engineering/architecture-optimization/introducing-sub-issues-enhancing-issue-management-on-github/) explicitly states: "**Dogfooding is a best practice at GitHub and it's how we build GitHub!**" The post details how they used their own "sub-issues" feature extensively while developing it, allowing them to experience the feature firsthand and identify pain points or areas for improvement.

This commitment to "dogfooding" offers several key benefits:

* **Deep Empathy with Developers:** GitHub's engineers experience the platform just as their users do. This fosters a profound understanding of developer needs, workflows, and frustrations, leading to more intuitive and effective tools.
* **Early Bug Detection and Quality Assurance:** Using features internally, in real-world development scenarios, is one of the most effective ways to catch bugs, performance issues, and usability quirks before they impact the broader community.
* **Rapid Iteration and Feedback:** The feedback loop is incredibly short. When a GitHub engineer encounters an issue or has an idea for an improvement while using GitHub, that feedback can be channeled directly to the relevant product and engineering teams.
* **Validation of New Features:** New ideas and experimental features can be prototyped and tested internally, providing quick validation of their utility and viability.
* **Driving Developer Experience (DevEx):** GitHub is keenly focused on Developer Experience. As Greg Mondello, Director of Product at GitHub, has emphasized, "improvements to the effectiveness of software development are inherently valuable." (Source: [Pulumi Blog](https://www.pulumi.com/blog/software-developer-experience-devex-devx-devops-culture/)) By prioritizing their own DevEx, GitHub ensures the platform remains a productive and satisfying environment for all developers.

### A Developer-First Culture

Thomas Dohmke, GitHub's CEO, often speaks about the company's developer-first ethos. "We are building the tools that other developers are using. We always say we put the developers first," he mentioned in the Sequoia Capital podcast. This philosophy means that the needs and experiences of their own highly skilled engineering workforce are paramount in shaping the platform. When GitHub's engineers demand better performance, more intuitive workflows, or more powerful automation, these demands often translate into features that benefit the entire GitHub community.

The company's engineering blogs, like the one on ["The art of engineering team focus,"](https://resources.github.com/developer-productivity/engineering-team-focus/?ref=feedle.world) share internal principles for shipping value, such as making work visible and defining it in small chunks. It notes, "At GitHub, this approach helped us evolve from shipping massive internal tools to making iterative improvements that benefited both our internal development teams and our customers," directly linking internal practices to external benefits.

### Challenges and Continuous Evolution

"Dogfooding" a platform as vast and complex as GitHub, especially while it's being actively used to develop itself, presents unique challenges. Managing updates, testing breaking changes, and ensuring stability for internal teams who rely on the platform for their daily work requires sophisticated engineering practices, likely involving feature flags, staged rollouts, and dedicated internal testing environments.

Furthermore, while GitHub's engineers represent an expert user base, the company must also ensure its platform remains accessible and intuitive for developers of all skill levels, from students and hobbyists to large enterprise teams. This balance is maintained through extensive community engagement, user research, and a strong Developer Relations program that constantly gathers feedback from the wider world.

### Conclusion: Building for Developers, By Developers

GitHub's commitment to using its own platform for every facet of its software development lifecycle is a powerful testament to its belief in its products and its dedication to the developer community. By being their own most critical "customer zero," GitHub's teams ensure that the tools they offer are not just feature-rich but also robust, reliable, and genuinely enhance the productivity and satisfaction of developers. This "GitHub on GitHub" approach is a fundamental reason why the platform continues to be the leading home for all developers, constantly evolving to meet the needs of a rapidly changing software landscape, with its own internal innovators leading the charge.

GitHub Builds on GitHub: How the Developer Platform Practices What It Preaches


In the fast-paced world of software development, there's a time-honored practice that often separates good products from great ones: "eating your own dog food," or dogfooding. It's the simple yet profound idea that companies should use their own products and services internally as a primary way to test, understand, and improve them. Etsy, the sprawling online marketplace for handcrafted and vintage items, has woven this philosophy into its development culture, leading to a more robust and user-centric platform.

While Etsy might not always shout "dogfooding" from the rooftops with a formal, branded program name, the principles are evident in their engineering practices, product rollout strategies, and company culture. They understand that to truly serve their vibrant community of millions of sellers and buyers, their own teams need to be deeply familiar with the platform's every nook and cranny – experiencing both its triumphs and its frustrations firsthand.

**Early and Continuous Internal Use: The Mobile App Example**

One of the clearest illustrations of Etsy's dogfooding commitment comes from its approach to mobile app development. As far back as 2014, reports highlighted how Etsy leveraged continuous integration principles not just for their web stack, but rigorously for their mobile applications as well. Instead of solely relying on external beta testers, Etsy would roll out continuous releases of its mobile apps to internal teams. This meant that Etsy employees were among the very first to use new features and iterations in real-world scenarios.

To facilitate this internal feedback loop, Etsy even developed tools like an internal "Bug Hunting tool." This allowed employees to report bugs directly from their devices, often attaching screenshots to pinpoint issues. Adding a touch of fun and engagement, there was even a level of gamification, with leaderboards recognizing the most prolific bug hunters. This approach not only helped in identifying and fixing bugs early but also fostered a sense of collective ownership and quality assurance across the company.

**A Culture of Experimentation: Dogfooding at Scale**

Etsy is renowned for its deeply ingrained culture of experimentation, particularly its extensive use of A/B testing. As detailed on their "Code as Craft" engineering blog and in various discussions by their product teams, nearly every change, from a button color to a new search algorithm, is often tested with a subset of users before a full rollout.

While A/B testing isn't dogfooding in its purest, most isolated form (where only employees use a pre-release version), it functions as a type of scaled dogfooding in Etsy's context. Employees, being active users of the platform for their own shopping or even as sellers themselves, are inevitably part of these experiment groups. They experience new features organically, providing an invaluable layer of sophisticated, internal "first users" before changes reach the entire user base.

This continuous experimentation allows Etsy to:

* **Gather Real-World Data:** See how new features perform under actual usage conditions.
* **Validate Hypotheses:** Test assumptions about user behavior and preferences.
* **Iterate Rapidly:** Make data-driven decisions and refine features quickly.

Etsy's "Building Better Tools With Experiments" guide for sellers even explains this philosophy, stating, "By testing new features with a small percentage of Etsy users, we gather valuable data that helps us ensure that the changes we make will have a positive impact for the majority of Etsy sellers." Employees are a critical, albeit often undifferentiated, part of that "small percentage."

**Encouraging Company-Wide Product Immersion**

Beyond formal testing, there's a cultural expectation at Etsy that encourages employees to engage deeply with the product. Cap Watkins, a former VP of Design at Etsy, articulated this well in a blog post about his design process. He emphasized the importance of company-wide dogfooding during development:

> Hopefully you've already had your entire company dog-fooding your new release during development. If not, it's time. Get everyone to use your product under real, live conditions. Gather feedback. Make adjustments.

[Cap Watkins, _My Design Process Part 3_](https://capwatkins.com/blog/my-design-process-part-3)

This sentiment underscores a proactive approach to getting the product in front of internal users. It’s about more than just QA; it’s about fostering empathy and ensuring that everyone, from engineers to marketers, understands the user experience from the inside out. When employees are encouraged to use the platform for their personal shopping, or if they run their own small shops, they naturally become critical and insightful testers of new seller tools and buyer-facing features.

**Focus on Seller Success: Internal Testing for a Better Toolkit**

Etsy's success is inextricably linked to the success of its sellers. Therefore, a significant portion of their development effort goes into creating and refining tools for shop owners. Recent pushes to enhance the Shop Manager dashboard, introduce AI-powered listing assistance, and provide real-time feedback on listing quality are prime examples.

While Etsy often beta tests these new seller features with "a select group of sellers," it's highly probable that employees who also run Etsy shops, or dedicated internal testing accounts, are among these early adopters. This allows Etsy to:

* **Understand Seller Pain Points:** Internal users can quickly identify clunky workflows or missing functionalities in new seller tools.
* **Refine Usability:** Ensure that new features are intuitive and genuinely helpful before a wider release.
* **Catch Edge Cases:** Discover unique scenarios or problems that might not be apparent in controlled testing environments.

**The Nuances and Potential Pitfalls**

Dogfooding, for all its benefits, isn't a silver bullet. One potential challenge is the "expert user" syndrome. Employees who are intimately familiar with the platform's architecture and upcoming features might not use the product in the same way a brand-new, less technically savvy user would. They might unconsciously work around bugs or understand convoluted features that would baffle an average customer. Etsy mitigates this through its extensive A/B testing with broader audiences and dedicated user research.

Another aspect is ensuring that feedback channels are open and that employees feel empowered to provide honest, critical feedback without fear of reprisal. Etsy's engineering culture, which emphasizes collaboration, transparency, and empowering developers, seems conducive to fostering such an environment.

**Conclusion: A Living Lab for a Thriving Marketplace**

Etsy's application of dogfooding principles, whether through direct internal releases, widespread experimentation, or a culture of product immersion, plays a crucial role in its continuous improvement. By having its own team members regularly use and scrutinize the platform, Etsy gains invaluable insights, catches issues earlier, and ultimately builds a more resilient, user-friendly, and innovative marketplace.

It’s this commitment to living within their own creation, to experiencing what their buyers and sellers experience, that helps Etsy "Keep Commerce Human" – not just as a tagline, but as a practiced reality in their product development lifecycle. While they may not always use the term "dogfooding," their actions speak volumes, demonstrating a clear understanding that the path to a better product often starts by looking inward.

Articles tagged with "Ci Cd"

GitLab on GitLab: How the DevOps Platform Builds Itself and a Culture of Iteration

GitHub Builds on GitHub: How the Developer Platform Practices What It Preaches

Etsy's Secret Sauce: How 'Eating Their Own Dog Food' Fuels a Better Marketplace