Best practices, optimization & learning resources
APM Insight delivers the most value when it's used continuously—not just during incidents. This document helps you move from reactive troubleshooting to proactive performance optimization, using APM Insight's features the way they were designed to be used.
Table of contents
1. Best practices for effective monitoring in APM Insight
Focus on business-critical transactions
Not all transactions deserve equal attention. In APM Insight, prioritize the transactions that directly impact revenue, customer experience, or SLAs.
How to do this in APM Insight
- In the APM Insight monitor, click on the Transactions tab
- Identify transactions with:
- High throughput
- High response time
- Direct business impact (checkout, login, payment)
- Mark them as Key Transactions
- Configure alerts and dashboards specifically for these transactions
Why this matters
Optimizing a rarely used admin API won't move the needle—but improving checkout latency by 500 ms can directly impact conversions.
Expected outcome
- Faster troubleshooting
- Alerts that matter
- Clear focus for optimization efforts
Monitor trends, not just spikes
A single spike might be noise. Gradual degradation is often more dangerous.
What to track in APM Insight
- Response time trends (7-day and 30-day averages)
- Apdex score trends
- Database query count growth
- Increase in external service latency
Where to look
- Overview page → Trend graphs
- Reports → Historical performance reports
Why this matters
A response time increase from 1.2s to 1.8s over two weeks may not trigger alerts—but it signals growing user frustration.
Expected outcome
Catch performance degradation weeks before users complain, enabling planned optimization instead of firefighting.
Fine-tune monitoring behavior using Agent Configuration Profiles
Why this matters
Different applications have different monitoring needs. The APM Insight Agent Configuration Profile allows you to fine-tune how web and background transactions are monitored by adjusting key configuration parameters.
This helps balance monitoring depth with operational stability—especially in high-throughput or production environments.
Best practice
Use Agent Configuration Profiles to control monitoring behavior centrally at the application level, ensuring consistent configuration across all application instances.
What you can configure
- Threshold values for web transactions
- Threshold values for background transactions
- Agent-specific monitoring parameters based on platform (Java, .NET, Node.js, etc.)
When configuration tuning is useful
- Applications with high transaction volume
- Environments where default thresholds are too aggressive or too relaxed
- During optimization efforts, to focus on specific transaction types
- To standardize monitoring behavior across multiple instances
Important note:- Agent Configuration Profiles are applied at the application level, not per instance.
- Any change made to a profile is automatically reflected across all instances of that application.
Where to configure
- Navigate to Settings → Discovery & Data Collection → APM Insight Agent Configuration Profile
- Create, clone, or edit profiles
- Associate the required profile with your application
Expected outcome
- Consistent monitoring behavior across all instances
- Better control over transaction tracking thresholds
- Reduced noise from non-critical transactions
- Monitoring that aligns with real application usage patterns
Integrate RUM for complete application visibility
Why this matters
APM Insight monitors server-side performance—application code, databases, and APIs. However, users experience the entire journey, from the server to the browser.
Client-side factors such as JavaScript execution, browser rendering, network latency, and asset loading can add several seconds to page load time—even when the server is fast.
The blind spot
Your server may respond in 500 ms, but if the page takes 4 seconds to fully load in the browser, users will still perceive the application as slow.
APM Insight alone cannot explain these client-side delays.
Best practice
Integrate Real User Monitoring (RUM) with APM Insight to achieve end-to-end visibility, from backend processing to actual user experience.
When RUM Integration is critical
RUM is especially important if your application is:
- Customer-facing (e-commerce, SaaS platforms)
- JavaScript-heavy (React, Angular, Vue)
- Used by a global audience with varied network conditions
- Mobile-responsive or mobile-first
- Showing good server metrics but still receiving user complaints
Quick Setup (≈5 minutes)
- Navigate to your APM Insight monitor
- Open the RUM Analytics tab
- Select the appropriate RUM monitor from the dropdown
- Click Associate
What You Gain
By combining APM Insight with RUM, you get:
- Client-side page load and rendering metrics
- JavaScript errors impacting user experience
- Performance insights by browser, device, and geographic location
- Unified server-side and client-side Apdex scores
Real-World Example: Finding Hidden Bottlenecks
Problem:
An e-commerce checkout flow showed a 650 ms server response time, indicating excellent backend performance. However, customers—especially mobile users—reported a "slow checkout" experience.
What RUM Analytics revealed:
- Desktop page load time: 1.8 s (acceptable)
- Mobile Safari page load time: 6.4 s (poor)
- Bottlenecks:
- Unoptimized images: 2.8 s
- Inefficient JavaScript execution: 2.1 s
Solution:
- Implemented responsive images with lazy loading
- Optimized the mobile JavaScript bundle
Result:
- Mobile page load time reduced to 2.1 s
- Cart abandonment dropped by 18%
- Customer complaints reduced by 89%
How to interpret APM + RUM together
| APM Insight (Server) | RUM (Client) | Likely Issue | Recommended Action |
|---|
| Fast (< 500 ms) | Slow (> 3 s) | Client-side bottleneck | Analyze RUM data (JS, rendering, assets) |
| Slow (> 2 s) | Also slow | Server-side issue | Use APM traces and optimize backend |
| Fast | Fast, but complaints persist | Specific user segments affected | Filter RUM by browser, device, or location |
Daily Monitoring Routine
- Review the APM Insight dashboard for server health
- Check RUM Analytics for client-side experience
- Compare server-side and client-side Apdex scores to identify gaps
Expected Outcomes
Short-term (first month):
- Visibility into previously hidden client-side issues
- Faster identification of server vs. client problems
- Better prioritization of optimization efforts
Long-term (6+ months):
- Improved user experience through targeted frontend optimizations
- Fewer "application is slow" support tickets
- Proactive detection of performance regressions
- Higher conversion rates and overall user satisfaction
✅ Do:
- Monitor both server-side and client-side Apdex scores
- Check RUM when server metrics look healthy but users complain
- Set alerts for both backend and frontend performance
❌ Don't:
- Assume fast server response equals good user experience
- Ignore RUM data just because APM metrics look fine
- Use RUM only during incidents—monitor proactively
For detailed RUM integration steps, refer to Document 1: Getting Started with APM Insight.
2. Using Apdex scores effectively
Setting Apdex thresholds that match business reality
Recommended starting thresholds:
| Transaction Type | Satisfied | Tolerating | Example |
|---|
| API Endpoints | < 500 ms | 500 ms—2 s | REST APIs |
| Web Pages | < 2 s | 2—8 s | Product/search pages |
| Checkout / Payment | < 1.5 s | 1.5—6 s | Revenue flows |
| Login / Auth | < 1 s | 1—4 s | Authentication |
| Background Jobs | < 30 s | 30—120 s | Reports, batch jobs |
| Admin Pages | < 3 s | 3—12 s | Internal tools |
Note: Remember that in APM Insight, the Tolerating zone is automatically calculated as 4 × T (Satisfied threshold). The values above reflect this relationship.
How to set Apdex in APM Insight
- Start with the industry thresholds above
- Monitor performance for 1 week
- Adjust thresholds:
- If Apdex < 0.7 → loosen thresholds temporarily
- If Apdex > 0.9 → tighten thresholds to drive improvement
- Review quarterly
Why this matters
Apdex directly reflects user satisfaction, not just technical performance.
Expected outcome
- Clear, measurable UX goals
- Fewer subjective performance debates
3. Systematic performance optimization process
Follow this monthly optimization workflow using APM Insight.
Week 1: Identify top opportunities
Database tab
Look for queries with:
- Total execution time > 5% of total DB time
- Execution time > 100 ms
- Execution count > 10,000/hour
Transactions tab
Focus on transactions with:
- Response time > 2× Apdex threshold
- Throughput > 1,000 requests/hour
Service map
Identify services with:
- Response time > 500 ms
- Increasing error rates
Week 2: Analyze & prioritize
- Use Transaction traces to find causes
- Prioritize based on:
- Apdex impact
- Business criticality
- Effort vs reward (quick wins first)
Week 3: Implement & validate
Optimize:
- Add DB indexes
- Refactor inefficient methods
- Introduce caching
Monitor for 48—72 hours
Compare before/after metrics:
- Response time
- Apdex
- Throughput
Week 4: Document & prevent regression
- Document changes
- Share results with stakeholders
- Add alerts to prevent recurrence
Real-world results
- Checkout time reduced from 3.2s → 1.1s
- Apdex improved from 0.78 → 0.94
- Multiple outages prevented through early detection
4. Use Milestones to Measure Optimization Impact
Best practice: Create milestones before and after optimization efforts to clearly quantify improvements and detect performance regressions early.
Recommended Milestone Cadence
For every deployment
- Create a pre-deployment milestone to capture the baseline
- Create a post-deployment milestone (after 24—48 hours)
- Compare metrics to quickly identify regressions or gains
Monthly performance reviews
- Create a milestone on the first day of each month
- Track month-over-month trends
- Spot gradual performance degradation or steady improvement
Before major optimizations
- Database query optimization → capture baseline first
- Code refactoring → document current performance
- Infrastructure upgrades → establish a comparison point
After major traffic events
- Product launches, campaigns, or peak traffic periods
- Compare performance under load vs. normal conditions
- Use insights to guide capacity and scaling decisions
Example: Quarterly Optimization Using Milestones
| Milestone | Apdex | Avg Response Time | Error Rate |
|---|
| Q1 Baseline (January 1) | 0.74 | 2.4s | 2.1% |
| After DB Optimization (February 15) | 0.84 (+13.5%) | 1.7s (—29%) | 2.0% (—5%) |
| After Code Refactor (March 22) | 0.91 (+8.3%) | 1.2s (—29%) | 1.3% (—35%) |
| Q2 Comparison (April 1) | +23% | —50% | —38% |
Result: Clear, data-backed evidence of optimization impact
Milestone Best Practices
✅ Do:
- Use descriptive names (e.g., "Pre v2.4 Deployment")
- Always create milestones before making changes
- Wait 24—48 hours after changes before comparing
- Document what changed between milestones
- Share milestone comparisons with stakeholders to demonstrate ROI
❌ Don't:
- Create too many milestones (limit: 50 per application)
- Compare milestones during abnormal traffic patterns
- Ignore gradual negative trends across milestones
- Create milestones without clear context or purpose
Interpreting Deviation Percentages
Milestone deviation highlights how metrics changed between time periods.
Positive deviations (improvement):
- Apdex increase: +15% (0.75 → 0.86) ✅
- Response time decrease: —30% (2.0s → 1.4s) ✅
- Error rate decrease: —50% (4% → 2%) ✅
Negative deviations (regression):
- Apdex decrease: —12% (0.88 → 0.77) ❌
- Response time increase: +45% (1.5s → 2.2s) ❌
- Error rate increase: +80% (1% → 1.8%) ❌
How to respond to regressions
- Identify what changed between milestones (deployment, config, traffic)
- Review APM Insight transaction traces for the affected period
- Roll back or fix if the regression is severe
- Create a new milestone after remediation to confirm recovery
5. Reading transaction traces effectively
How to identify disproportionate execution time
In the Transaction Trace view, look for:
- Methods consuming >30% of total transaction time
- Repeated method calls
- Queries executed multiple times per request
Prioritization rule:Optimize methods that are:
- Slow and
- Executed frequently and
- Part of key transactions
6. When to use custom instrumentation
Scenario: The mystery delay
Your checkout transaction shows 3 seconds, but traces account for only 1.2 seconds.
Cause: Uninstrumented legacy or third-party code.
Solution: Add custom instrumentation.
Use custom instrumentation for:
- Legacy modules
- Business-specific workflows
- Third-party libraries not auto-instrumented
- Gaps in trace visibility
Where to configure
Use the Custom Instrumentation configuration in APM Insight.
Expected outcome
Complete visibility into hidden performance bottlenecks.
7. Alert configuration strategy
Two-tier alert system
Tier 1 — Warning alerts
(Investigate during business hours)
- Response time > 3s for one or more consecutive 5-minute cycles
- Apdex score < 0.75 for two consecutive 5-minute cycles
- Error rate > 2% for one or more consecutive 5-minute cycles
Tier 2 — Critical alerts
(Immediate action required)
- Response time > 5s for two consecutive 5-minute cycles
- Apdex < 0.5 for one or more consecutive 5-minute cycles
- Error rate > 10% for one or more consecutive 5-minute cycles
Alert fatigue prevention
- Rely on sustained 5-minute evaluation windows instead of instant spikes
- Configure maintenance windows during deployments and planned changes
- Review alert thresholds monthly and adjust based on real-world incidents
- Disable or tune alerts that do not lead to clear actions
8. Enterprise deployment best practices
For multi-team environments
- Assign monitors by application ownership
- Configure team-specific alerts
- Create role-based dashboards
For distributed & microservices systems
- Use Service Map to track dependencies
- Monitor each service as a separate instance
- Enable cross-application visibility
For high-traffic applications
- Enable sampling where applicable
- Use different data retention for:
- Business-critical apps
- Internal tools
- Leverage reports for capacity planning
For compliance & audits
- Document monitoring coverage
- Use reports to demonstrate SLA adherence
- Configure retention policies as required
9. Learning & support resources
Final outcome
By following these best practices, teams using APM Insight can:
- Prevent performance issues instead of reacting to them
- Align monitoring with business impact
- Scale observability across teams and environments
- Continuously improve application performance with confidence