5 ways New Relic AI makes my life easy as an engineer

As engineers, we’re constantly juggling priorities; resolving production issues, optimizing performance, and ensuring systems remain resilient under pressure. The complexity of modern applications and their sprawling infrastructures often means spending hours sifting through logs, writing custom queries, and piecing together scattered insights. This is where New Relic AI has truly made a difference. By leveraging large language models (LLMs), it allows me to interact with system data in a way that feels more natural. Instead of wrangling with raw data or creating complex queries, I can ask questions in plain English and get meaningful, actionable insights right away. It's a game-changer for simplifying workflows and helping me focus on what truly matters.

In this blog post, I’ll share four ways New Relic AI has made my engineering work easier, faster, and less stressful. Whether it’s identifying hidden issues, automating tedious tasks, or streamlining monitoring, you’ll see just how this tool has transformed my approach to observability.

1. Streamlined debugging

Debugging can be one of the most time-consuming tasks for an engineer, especially when dealing with large, distributed systems. When something breaks, your first instinct is to dive into logs, but that often means wading through hundreds or thousands of lines of text to figure out what went wrong. New Relic AI changes the game by making log analysis not just faster, but smarter. Instead of manually searching through logs, you can ask New Relic AI questions in plain language, and it will summarize errors, highlight patterns, and even suggest next steps.

Imagine you're working on the Ad service during a high-traffic event, and some transactions start failing intermittently. Instead of jumping into multiple log files, you query New Relic AI with something like:

Why are some transactions failing in my Ad Service?

New Relic AI instantly generates a query in New Relic Query Language (NRQL) and provides a high-level count of failing transactions, as shown below:

From there, you refine the query further to identify error types and root causes. Simply ask:

Why are these transactions failing?

The AI returns a detailed breakdown of the errors, including class, messages, and counts. For example, it might reveal that failures are caused by SQL connection issues and timeouts:

The above screenshot shows two errors:

• java.lang.Exception: SQL connection failed (Too many connections), indicating that your database has hit the maximum connection limit, causing queries to fail.
• java.util.concurrent.TimeoutException: Context timed out, which hints that requests to an external service or resource are exceeding the timeout threshold.

With this quick summary, you don’t waste time searching through massive logs. Instead, you focus directly on resolving the connection bottleneck and optimizing external dependencies. This capability saves valuable time and reduces the cognitive load during high-pressure situations, allowing you to resolve issues faster and more effectively.

2. Writing NRQL queries with natural language

If you’ve been using New Relic, you know that NRQL is the backbone for querying your telemetry data. Whether you’re analyzing system metrics or tracking errors, NRQL gives you the power to extract meaningful insights. However, writing these queries, especially when you're pressed for time or unfamiliar with the syntax, can slow you down. With New Relic AI, you don’t need to memorize or manually construct NRQL. Instead, you describe what you need in plain language, and the AI generates the query for you.

Let’s say you’re monitoring your Frontend service and you want to check the response time of your service. To analyze the performance, you can simply ask:

What is the average response time for my Frontend service in the last hour?

New Relic AI will generate the following query:

Similarly, instead of focusing on a single metric, you can also query the performance overview of your services. Simply ask:

Show me the performance of Payment Service

New Relic AI will generate and execute the following query:

The screenshot below shows the performance metrics, such as the average duration and transaction count of the Payment service for the past hour.

3. Understanding dashboard insights quickly

Dashboards are an essential part of observability, providing visual insights into system performance, usage trends, and health metrics. However, when you’re dealing with complex dashboards that combine multiple graphs, it can sometimes be unclear where to focus—especially when you’re unfamiliar with the data or need a quick overview. New Relic AI solves this by summarizing dashboards in plain language. Instead of toggling between charts and hunting for patterns, you can simply ask what the dashboard shows, and New Relic AI will provide a concise summary of the most relevant insights.

Let’s say you’ve just been assigned to monitor a new service, and your team has already created a dashboard for it. To get up to speed quickly, you can ask:

What's on this dashboard?

New Relic AI analyzes the dashboard and provides key takeaways. Below is an example of a dashboard summary in New Relic.

With this summary, you can quickly grasp the overall performance and spot any trends without analyzing every individual graph. This feature is particularly useful when onboarding new team members, or preparing for a last-minute performance meeting. It lets you focus on what matters, saving you from spending unnecessary time decoding graphs.

4. Ensuring comprehensive alert coverage

Alerts are usually the first line of defense for an engineer when something goes wrong. Without proper alert coverage, critical issues can slip through unnoticed, leading to outages or performance degradation. However, manually verifying alert configurations for every entity in a complex system is an engineer’s nightmare. I would rather be fixing the actual issue than verifying the alert coverage. New Relic AI makes it possible to quickly identify entities, services, hosts, and applications that don’t have alerts set up. To identify unmonitored services, you can start by asking the assistant to find the gaps in your stack or a particular portion of your stack.

Show me the APM services that are not covered by an alert

The above prompt will likely generate a list of APM services that lack alert coverage. 

Once you’ve identified these gaps, you can set up the alerts using the same New Relic AI assistance, UI, or REST API.

5. Simplifying synthetic monitoring

Synthetic monitoring ensures that your critical services are always available and performing as expected by simulating user interactions. However, setting up these monitors manually and defining configurations, schedules, and thresholds can be an unnecessary bottleneck.

With New Relic AI, all it takes is a simple description. For instance, if you need to track the uptime of your API endpoint, you can ask:

Set up a ping monitor for my Checkout Service

New Relic AI responds with the interface to creating the ping monitor.

You can configure the ping to your specifications and it will provide immediate visibility into uptime and response times. No menus, no back-and-forth. Just instant results tailored to your needs. This feature isn’t just about convenience; it’s about making proactive monitoring accessible and efficient, ensuring your services remain resilient even before users notice a problem.

Conclusion

Engineering is all about solving problems, but the tools we use can make all the difference in how efficiently we do it. New Relic AI has redefined how I approach observability, turning tasks that used to take hours into actions that take mere minutes. From writing NRQL queries with natural language to understanding dashboards and ensuring full alert coverage, New Relic AI has simplified my workflows and helped me focus on what really matters, building resilient, high-performing systems.

If you’re an engineer looking for ways to work smarter, not harder, New Relic AI is worth exploring. It’s not just a tool; it’s a game-changer for modern observability.