Application Performance Management (APM) with New Relic Training Course

Introduction to Application Performance Monitoring

• Grasping the fundamentals of Application Performance Management (APM) and its critical role in modern application operations
• Understanding the interplay between application performance, availability, reliability, and the overall customer experience
• Defining key application performance indicators (KPIs) and service-level objectives (SLOs)
• Recognising common sources of application performance degradation
• An overview of the application monitoring lifecycle: observe, analyse, diagnose, remediate, and optimise
• Understanding New Relic's position within full-stack observability strategies

New Relic Features and Architecture

• An overview of the New Relic platform and its core capabilities
• Exploring New Relic architecture and data flow mechanisms
• The role of New Relic agents, collectors, and telemetry data
• Overview of key data types: metrics, events, logs, traces, and errors
• Application Performance Monitoring (APM), browser monitoring, infrastructure monitoring, and database monitoring
• Understanding the distinction between entities, services, applications, and workloads
• An introduction to distributed tracing and service dependencies
• Concepts regarding data retention, querying, and visualisation

Navigating the New Relic User Interface

• Getting started with the New Relic platform and primary dashboards
• Managing applications, services, hosts, and entities
• Exploring performance summaries and application health status
• Utilising charts, tables, filters, and time-range selections
• Searching through and analysing telemetry data
• Customising dashboards and specific views to suit team needs
• Creating effective operational and performance dashboards
• Using New Relic to transition from high-level symptoms to detailed diagnostics

Setting Up and Configuring New Relic Agents

• Understanding New Relic agent architecture and supported environments
• Installing New Relic agents on application servers
• Configuring agents for application-specific monitoring requirements
• Instrumentation strategies: automatic versus manual instrumentation
• Setting up browser and end-user monitoring
• Validating agent installation and telemetry data collection
• Managing configuration and environment-specific settings
• Troubleshooting common agent installation and data collection issues
• Best practices for secure and maintainable agent deployment

Measuring Application Performance from the End-User Perspective

• Understanding Real User Monitoring (RUM)
• Measuring page-load times and application response rates
• Monitoring browser performance and user interactions
• Identifying slow pages, transactions, and user journeys
• Analysing performance variations across geographies and devices
• Correlating end-user experience with backend application performance
• Identifying performance issues that directly impact customer satisfaction
• Using performance data to prioritise optimisation activities

Reading and Understanding Instrumentation Data

• Understanding transaction traces and application transactions
• Interpreting response time, throughput, and error-rate data
• Understanding transaction breakdowns and performance segments
• Analysing external services and dependencies
• Examining application errors and error traces
• Identifying bottlenecks from instrumentation data
• Using traces to track requests across application components
• Correlating metrics, events, logs, and traces for root-cause analysis
• Practical exercises in interpreting application telemetry

Measuring Application Resources and Infrastructure

• Monitoring application and server resource utilisation
• Understanding CPU, memory, disk, and network performance
• Identifying resource saturation and capacity-related issues
• Correlating infrastructure metrics with application response times
• Monitoring application processes and workloads
• Identifying resource-intensive transactions
• Investigating performance degradation caused by infrastructure constraints
• Establishing performance baselines and identifying abnormal behaviour

Monitoring and Notifications

• Understanding New Relic alerting concepts
• Defining alert conditions and thresholds
• Creating alerts for application performance and availability
• Monitoring error rates, response times, throughput, and resource utilisation
• Designing actionable alert policies
• Configuring notification channels and incident workflows
• Reducing alert noise and avoiding unnecessary notifications
• Understanding incidents and issue correlation
• Testing and validating alert configurations
• Best practices for proactive application monitoring

Monitoring Database Operations

• Understanding the relationship between database performance and application performance
• Monitoring database calls and query activity
• Identifying slow database operations
• Analysing database response times
• Detecting inefficient or resource-intensive queries
• Correlating database operations with application transactions
• Investigating database-related application bottlenecks
• Using performance data to improve query response times
• Practical exercises for diagnosing database performance issues

Reporting and Visualizing Application Performance

• Creating meaningful performance reports
• Building dashboards for development, operations, and management teams
• Selecting appropriate metrics for different audiences
• Visualising application availability, response time, throughput, and errors
• Tracking performance trends over time
• Comparing application performance across environments
• Presenting technical metrics as business-relevant insights
• Establishing performance baselines and reporting against objectives

Analyzing and Optimizing Application Performance

• Establishing a systematic application performance analysis process
• Identifying performance bottlenecks and abnormal behaviour
• Analysing transaction response times and throughput
• Comparing current performance with historical baselines
• Correlating multiple telemetry sources during investigations
• Prioritising performance problems according to user and business impact
• Identifying opportunities for application optimisation
• Validating performance improvements using New Relic data
• Hands-on performance analysis exercises

Troubleshooting API and Service Issues

• Monitoring APIs and external service dependencies
• Measuring API response time, throughput, and error rates
• Identifying slow and unreliable API endpoints
• Diagnosing timeout and connectivity issues
• Analysing failed API transactions
• Using traces to identify bottlenecks across distributed services
• Correlating API problems with downstream dependencies
• Identifying the root cause of API performance degradation
• Developing and validating remediation strategies

Distributed Tracing and End-to-End Troubleshooting

• Understanding distributed applications and service dependencies
• An introduction to distributed tracing concepts
• Following requests across multiple application services
• Identifying latency introduced by individual services
• Analysing service-to-service communication
• Detecting failures across distributed application components
• Correlating traces with logs, errors, and infrastructure metrics
• Performing end-to-end root-cause analysis
• Practical troubleshooting scenarios using a live-lab environment

Querying and Analyzing New Relic Data

• An introduction to querying telemetry data in New Relic
• Understanding the New Relic Query Language (NRQL)
• Writing queries to investigate application performance
• Filtering and aggregating metrics and events
• Analysing response times, errors, throughput, and transaction data
• Creating custom visualisations from query results
• Using queries to support troubleshooting and reporting
• Building reusable queries and dashboards
• Practical NRQL exercises

Integrating New Relic with Third-Party Tools and Services

• Overview of New Relic integrations
• Integrating New Relic with infrastructure and cloud platforms
• Connecting monitoring data with collaboration and incident-management tools
• Understanding integration workflows and data exchange
• Configuring notifications and external service integrations
• Using integrations to support DevOps and incident-response processes
• Best practices for maintaining reliable monitoring integrations

Practical Troubleshooting Workshop

• Investigating a simulated application performance incident
• Identifying symptoms from end-user performance data
• Analysing application transactions and errors
• Investigating infrastructure and database performance
• Tracing API and external service dependencies
• Correlating metrics, events, logs, and traces
• Identifying the most likely root cause
• Developing and validating a remediation approach
• Configuring alerts to prevent recurrence
• Documenting findings and communicating business impact

Monitoring Best Practices and Operational Recommendations

• Designing an effective New Relic monitoring strategy
• Selecting meaningful performance and availability metrics
• Establishing baselines and service-level objectives
• Avoiding excessive monitoring noise
• Developing effective alerting and escalation practices
• Maintaining consistent monitoring across development, testing, and production
• Using observability data to support continuous improvement
• Translating technical performance data into actionable business insights

Summary and Conclusion

• Review of New Relic architecture and core capabilities
• Review of application, infrastructure, database, API, and end-user monitoring
• Recap of troubleshooting and root-cause analysis techniques
• Review of alerting, dashboards, reporting, and integrations
• Final hands-on performance investigation
• Discussion of real-world implementation scenarios
• Questions and answers
• Recommended next steps for applying New Relic in production environments