Dogfooding DevCycle with DevCycle

What is “dogfooding”?

Dogfooding, also known as eating your own dog food, is the practice of using your own product or software to gain a better understanding of its features, user experience, and potential issues. Some of the key benefits of dogfooding include:

Identifying issues early on:

‍When you use your own software, you can identify bugs or issues that may not be apparent during development or testing. This allows you to fix them early on, before they become more significant problems.

Improving user experience:

By using your software regularly, you can gain a better understanding of how users will interact with it. This can help you make adjustments to the user interface or user experience to make it more intuitive and enjoyable to use.

Encouraging innovation:

When you use your own software, you may find new and innovative ways to improve it. This can lead to new features or enhancements that make your product more valuable to your customers.

Demonstrating confidence in your product:

Dogfooding your software sends a clear message to your customers that you have confidence in your product. It shows that you believe in what you've created and are willing to use it yourself.

Our beginning ✨

When we began building DevCycle, we decided from the get-go that we would also use DevCycle’s feature flags to release features within our own platform. As soon as we had a functional SDK, we started using it in the development of our dashboard. Naturally, integrating an unpolished product came with challenges, but by blocking our own workflow we were forced to fix bugs and improve the user experience quickly. In the beginning, dogfooding helped us identify pain points, unhandled edge cases, and ultimately be the first real users of our product.

Learning along the way 🛠️

Our dogfooding journey didn’t end after we launched DevCycle. In fact, to this day, we continue to expand the usage of our own platform to find out what’s working and what’s not. Here are a few things we’ve learned about our platform along the way:

We weren't accounting for high volume.

‍While developing a new tool, it can be easy to fall into the trap of only testing with new projects and sample applications, and think everything is working as expected. In the spirit of dogfooding, we set out to integrate DevCycle into our existing Taplytics codebase, and quickly realized that our methodology for tracking events wasn’t able to handle our own high traffic. By being our own first “high volume user” we had the time and flexibility to rethink our event aggregation before it was in the hands of real users.

Flag often, and flag granularly.

DevCycle's feature flags have played a critical role in helping us achieve CI/CD, deploy faster, and ship with confidence. We now use them for every new feature release, allowing us to rollout features gradually and test in production. 

One thing that differentiates DevCycle from other feature flagging platforms is the ability to group multiple variables within a single feature. In practice, this gives us the ability to independently toggle aspects of a feature, saving us from fully disabling a feature when a deployment doesn’t go as planned. Being able to flag on this granular level allows us to release features in stages as development is completed and speeds up our overall release process.

There’s always room for improvement.

By using our platform day-to-day, we get to experience firsthand which areas can be improved — both within our own tool and within the industry. Many of our integrations, such as our GitHub actions, CLI, or Terraform Provider, were conceptualized because developers on our team saw a need for them, and found a way to improve our own development cycle. As regular users of DevCycle, we are enabling innovation within our team, platform, and the entire feature management industry.

Eat your own dog food

Dogfooding will continue to be an essential part of how we work at DevCycle. We aim to build tools that make developer’s lives easier and tools that developers are excited to use, and doing so starts with us. Being able to use and improve the tools we build translates into a genuine excitement to share them with the rest of the developer community.