Visit AppSignal.com

Getting high on our own supply

Wes on

Scratching our own itch

The team behind AppSignal has been active in the Ruby on Rails community since 2005. We were the second company in the Netherlands to use it in production. We started AppSignal in 2012, after the launch of Rails 3 and its introduction of ActiveSupport::Notifications.

At that time, there was only one proper monitoring solution on the market: New Relic. Within our peer group, we received a lot of complaints about their product, pricing and sales tactics. Our own experiences with them were not great either; we needed a better solution. We decided to go and build a better product for ourselves and our clients. So we created AppSignal.

Eating our own dog food

We were able to find a few launching customers that were willing to test our product while paying for it from day one. They gave us some great feedback. After a little while, we set up a second AppSignal environment and started monitoring AppSignal with AppSignal. We were now eating our own dog food.

Insights from using our own product

Using our own product extensively has given us some great insights. These are some of the greatest learnings:

Do we actually use it?

If you do not find yourself using your product on a regular basis, that’s a strong signal. We have spoken with some startups that confessed that they do not actively use their own product. Maybe their product isn’t good enough for their customers either.

We feel the pain of missing features

In the past, we sometimes missed features or pieces of information in our app. This kept us from properly debugging issues with AppSignal. We were able to identify and fill these gaps effectively because of that, though we still have a roadmap filled with great new things we would enjoy using ourselves.

Having a playground

Another great thing is always having a playground to test new ideas on. We roll out new features in a very crude state, and refine it based on our own experience before shipping a beta to our customers. Having this live environment with a production dataset is very valuable.

Instant feedback

There’s probably no customer that uses AppSignal as much as we do. Often we find (and fix) issues before our customers notice them.

The blind spots

You have to watch out for blind spots when using your own software. Here’s some things that you should keep an eye on:

Never experiencing it fresh

We almost never have to go through the flow of installing AppSignal from scratch. Installing the gem, pushing data, inviting team members and setting up integrations is an integral part of the customer experience. It’s important to experience your product from scratch. This is why we regularly go through this process ourselves. Watching other customers do this in a usability test is also a great tool for learning.

Not all of our customers are like us

We run a SaaS. Some of our clients are agencies, working on multiple client projects with both freelance and internal developers. Never forget that not all our customers share your needs, and that many have needs that you do not.

Our own itch is limited

By focussing on your own itches, you could miss major opportunities in the market. We built a monitoring tool for Ruby, but there are opportunities for building software for other industries as well. There’s dentists, construction companies, restaurants and saunas that probably have exciting opportunities for a talented team to scratch their itches.

We love using AppSignal

It’s great to use AppSignal ourselves. It gives us a feeling of pride, knowing we built something so many people love (including ourselves). We highly recommend scratching your own itch and build a company out of it, but make sure you don’t limit yourself to those problems. There might be some problem way out of your comfort zone, waiting to be turned into a business.

10 latest articles

Go back

Subscribe to

Ruby Magic

Magicians never share their secrets. But we do. Sign up for our Ruby Magic email series and receive deep insights about garbage collection, memory allocation, concurrency and much more.