How startup BiteSite uses New Relic free tier to improve performance in minutes

At BiteSite, we’re a small custom software agency that builds web and mobile applications for small and medium-sized businesses. We develop using Ruby on Rails using React as our front-end framework. Given our size, scaling is always a big challenge. Free or low-cost solutions help maximize what we provide to our customers. When we started using New Relic at BiteSite, we had no idea the value it would be providing us over 10 years later.

From a simple hack to serious value

In the early 2010s, I started learning Ruby on Rails through online tutorials. That’s how I discovered a platform-as-a-service company called Heroku. Today it’s still the primary deployment platform that we work with. We began on Heroku’s free plan, but there was a small performance challenge: if you didn’t access your app for over 30 minutes, your server would spin down to save resources. The next time you tried to access the server, it would take around 30 seconds to spin back up which in web can be a real problem. We needed a way to keep hitting the server consistently to keep the server alive, so we turned to New Relic. New Relic was an amazing hack to get around that problem. We could use the New Relic plugin to Heroku for availability monitoring and that would ping our website every minute to keep the server running. 

Later on, one of our developers was dealing with an unrelated performance issue and since we had New Relic up and running, he decided to take a look at it. What he discovered was how easy it was to dissect performance problems with New Relic. We then started to look deeper into the New Relic free tier.

Improving performance and allocating resources

Web application performance is centered around transactions, each of which can be broken down into a series of steps. From a high-level, when a user accesses a website or performs an action on a website, the browser sends a request to the server, the server interprets the request, optionally collects and processes data from a database, perhaps performs some calculations, puts together a response and sends it to the user. Each one of those steps can add to the total response time, and our goal is to get each step as close to zero as possible. The closer to a zero response time we can get, the better the experience for the user. These days even a few seconds of waiting can frustrate a user.

When we embark on a web project, we don’t have all the time and resources to focus on perfect performance from the very beginning. We believe in Agile development and building a minimum viable product (MVP), which our customers appreciate as it helps them save money. So in the early phases of a project, a lot of time we don’t address performance. However, when a customer tells us that one of their pages is broken or loading slowly, we turn to our New Relic transaction dashboard.

In New Relic, everything is tracked automatically. Unlike other platforms, we don’t have to pick and choose what’s important from the outset. So when a customer has an issue, we know we’ll have the data we need. For example, when a customer says something is loading slowly, New Relic might show that the fetch to the database is taking up 20% of the response time, while the HTML render is only taking up 5%. This information is immediately actionable—we understand where the performance problem is and can work on reducing it. It’s not just that the information from New Relic is actionable, but the solution is usually very easy to implement. 

Not only that, New Relic also helps us validate our solution. Within minutes of pushing our changes to production, we can see how our fix is doing by looking at the transactions again and seeing the changes in performance time. Not only is this good for validation, but also good for general programmer morale.

Quick actionable, easy-to-implement solutions with validation are invaluable to our agency as a small business. We may not use New Relic all the time, but when we do, it consistently delivers value for our customers. 

Availability monitoring for small organizations

It’s a testament to the New Relic user experience that there wasn’t a big learning curve when we started using it for transaction and application monitoring. It was a self-serve experience and the initial stats were easy to understand and I didn’t need to read documentation. The learning process was just a matter of getting proof—it’s as easy as finding what to fix and fixing it.

There are a lot of tools that we come across as developers, and there’s a lot of things that we get excited about at first. But few lead to actionable change and have a real lasting impact, especially for small businesses. We have such limited resources—fancy tools are rarely worth it for us to use or pay for. New Relic is among the few tools where it’s very clear what the value is and the difference it makes in our day-to-day development.

This is what we love about the New Relic free tier: it gives you a perfect roadmap. Here’s the situation now, here’s what you need to fix, and here’s what it will look like after you fix it. With other tools, you might make a change but not see the effect for months or even years. With New Relic, you see the change within minutes. We don’t use New Relic as frequently as we could, but when we do, the impact is immediately clear.