Free Practice Questions for the Cisco AppDynamics Certified Associate 500-420 Exam (2026 Updated)

Memory Used% and CPU %Busy are the two KPIs that directly measure server-level resource consumption.

Memory Used% represents the proportion of physical memory currently consumed on the monitored server. A sustained high value can indicate memory pressure, excessive process allocation, insufficient capacity, or conditions that may lead to paging and degraded application performance.

CPU %Busy measures the percentage of processor capacity actively being used. It is a primary indicator of compute-resource utilization and helps identify CPU saturation, processing bottlenecks, or insufficient server capacity. Persistent high CPU utilization may correlate with increased response time, transaction queuing, and reduced throughput.

The remaining options describe availability, application behavior, or transaction performance rather than direct infrastructure-resource consumption. Calls per Minute measures workload volume, Average Response Time measures transaction latency, Availability indicates whether a system or service is reachable, and Application Restarts records lifecycle events.

Relevant CAAPA Study Guide topics include Server Visibility, Infrastructure Monitoring, Hardware Resource Metrics, CPU Utilization, Memory Utilization, and Correlating Server Health with Application Performance.

To confirm if a memory leak is occurring, one should refer to the Tiers and Nodes section of the AppDynamics Controller UI, navigate to the Memory tab, and observe the Heap Utilization over time in relation to the Heap ' s Current Usage (MB) versus the Maximum (MB) allocated. Consistent growth in heap utilization or an upward trend that does not decrement even after garbage collection indicates a potential memory leak.

An Information Point is created to gather application-specific business and performance metrics from a selected class and method. It enables AppDynamics to monitor code that represents a meaningful business activity even when that method is not a Business Transaction entry point. Typical examples include tracking order value, number of items processed, cache access frequency, payment amounts, or invocations of a critical internal service.

Information Points can report measurements such as calls per minute, average response time, errors per minute, and configured custom numeric values. These metrics can then be displayed in the Metric Browser, compared against baselines, incorporated into dashboards, and evaluated by health rules.

Information Points are not limited to a particular Business Transaction, making option B too restrictive. Collecting fields specifically for Analytics queries is generally handled through transaction analytics and data collectors. Memory-leak troubleshooting instead uses memory diagnostics, object-instance tracking, heap analysis, and leak-detection capabilities.

Relevant CAAPA Study Guide topics include Information Points, Method-Level Monitoring, Business Metrics, Custom Metrics, Metric Roll-Ups, Dynamic Baselines, Health Rules, and Application Instrumentation.

AppDynamics supports HTTP data collectors and method invocation data collectors for enriching transaction snapshots with contextual diagnostic information.

An HTTP data collector captures selected request details associated with a Business Transaction, including URL or URI information, query or form parameters, HTTP headers, and cookies. These values help analysts distinguish transaction variants, correlate user input with application behavior, and identify request-specific causes of latency or errors. Sensitive values should be filtered or excluded through data-collection configuration.

A method invocation data collector captures information from instrumented application methods. Depending on configuration and agent support, it can collect method arguments, object properties, local or instance data, and return values. This provides code-level context when examining transaction snapshots and call graphs.

URN, URI, and SNMP are not separate AppDynamics transaction data-collector categories in this context. URI-related values are handled under HTTP request data collection, while SNMP belongs to network-management protocols rather than Application Agent transaction diagnostics.

Relevant CAAPA topics include Transaction Data Collectors, HTTP Request Data Collection, Method Invocation Data Collection, Transaction Snapshots, Sensitive Data Filtering, and Business Transaction Diagnostics.

The Performance Analyst should use Compare Against Baseline. This flow-map function provides an immediate comparison between current application behavior and the established historical baseline for the selected time range. It helps identify whether response time, load, call volume, or dependency behavior has deviated from what AppDynamics considers normal.

In the exhibit, the yellow downstream applications indicate a warning state, even though the blue flow lines suggest that the current calls themselves are not showing an obvious critical condition. Comparing the current flow map against baseline allows the analyst to determine whether those downstream dependencies are performing worse than their customary levels and whether the tier’s dependency pattern has changed.

Correlation Analysis is intended to identify statistical relationships among metrics rather than provide a direct historical flow-map comparison. Health Rule Violations show triggered conditions but do not provide the fastest visual comparison with prior performance. Metric Browser Baselines can expose baseline values for individual metrics, but require more manual investigation.

Relevant CAAPA topics include Application Flow Maps, Dynamic Baselines, Compare Against Baseline, Dependency Analysis, and Health-State Interpretation.

The three KPIs that most directly quantify customer experience are Business Transactions 94th Percentile Response Time, End User Response Time, and Business Transactions Errors per Minute.

The 94th percentile response time indicates how long the majority of Business Transaction executions take while reducing the masking effect of averages. It reveals whether a meaningful portion of customers is experiencing slow checkout, search, cart, or order-processing operations.

End User Response Time measures the customer-observed time required for a browser or mobile interaction to complete. It includes client-side processing, network latency, content loading, and server response, making it the most direct representation of perceived application performance.

Business Transactions Errors per Minute quantifies failed application operations. A rising error rate can represent unsuccessful logins, payment failures, rejected orders, or other outcomes that directly impair the customer journey.

Network incoming errors, Machine Agent availability, and CPU utilization are valuable infrastructure indicators, but they measure supporting-system health rather than customer experience itself.

Relevant CAAPA Study Guide topics include End User Monitoring, Business Transaction Performance, Percentile Response Time, Error Monitoring, Customer Experience KPIs, and Application Performance Correlation.

Business Transaction Discovery Sessions allow a Performance Analyst to browse the application’s classes and methods while identifying suitable entry points for custom Business Transaction detection. The discovery process observes application execution and exposes loaded or invoked code structures, enabling the analyst to locate the class and method that represent the beginning of a meaningful transaction.

Browsing classes helps narrow the search to the relevant package or application component. After selecting a class, the analyst can inspect its methods and choose the appropriate method as the transaction entry point. This is particularly useful when automatic discovery does not recognize a proprietary framework, background process, scheduled task, or other nonstandard execution path.

Database Calls are analyzed as exit calls or backend activity rather than browsed as transaction entry-point code. JMX MBeans are accessed through JMX monitoring and metric configuration tools. Memory Objects are examined through memory diagnostics, object instance tracking, or leak-detection functions, not Business Transaction Discovery Sessions.

Relevant CAAPA Study Guide topics include Business Transaction Discovery Sessions, Class and Method Browsing, Custom Match Rules, Entry-Point Configuration, Automatic Discovery, and Application Agent Instrumentation.

A Scope is used to apply Transaction Detection Rules selectively to one or more tiers that perform the same or a related application function. Scoping allows a Performance Analyst to avoid applying a custom match rule or exclude rule across the entire application when the relevant entry point, framework, class, method, or request pattern exists only within particular tiers.

For example, several web-service tiers may use the same transaction naming convention or custom entry-point logic. The analyst can group those tiers within a scope and associate the transaction detection rule with that scope. This provides consistent detection behavior while preventing the rule from affecting unrelated application tiers.

Scopes are not primarily defined for individual nodes because nodes inherit transaction detection behavior from their tier-level configuration. They are also not used for backends, which are identified through exit-point and backend detection configuration. Transaction Detection Rule scopes remain within the context of a single monitored application and are not used to distribute one rule across multiple applications.

Relevant CAAPA Study Guide topics include Transaction Detection, Rule Scopes, Tier-Level Instrumentation, Custom Match Rules, Exclude Rules, Entry-Point Detection, and Application Agent Configuration.

Both Service Endpoints and Business Transactions in AppDynamics have the capability to configure data collectors. Data collectors are used to gather detailed information about transactions or endpoints, such as method parameters, return values, and SQL statements.

Comprehensive and Detailed Explanation From Cisco AppDynamics Associate Performance Analyst (CAAPA):

Information Points provide method-level performance monitoring for selected application classes and methods without requiring those methods to be defined as Business Transaction entry points. They generate metrics such as Average Response Time, Calls per Minute, and Errors per Minute for the configured method.

Because Information Point response-time metrics are reported to the Controller, a Performance Analyst can compare the method’s current response time against a dynamic or configured baseline. This supports proactive detection of abnormal method performance.

Information Points also measure invocation frequency. Therefore, they can reveal changes in how often a method—such as a cache access method—is called. A sudden increase or decrease in Calls per Minute can indicate altered application behavior, cache inefficiency, reduced traffic, or a code-path change.

Information Points do not directly trigger a transaction snapshot whenever the configured method executes. Snapshot collection is governed by Business Transaction monitoring, diagnostic sessions, and snapshot collection rules. Excluding a specific exception from error detection is handled through error-detection and ignored-exception configuration, not Information Points.

Relevant CAAPA Study Guide topics include Information Points, Method-Level Metrics, Calls per Minute, Average Response Time, Dynamic Baselines, Health Rules, and Error Detection Configuration.

The Metric Explorer in AppDynamics allows Performance Analysts to define and visualize Key Performance Indicators (KPIs) from a selection of metrics. By accessing the Transaction Analytics data set, analysts can create custom dashboards that focus on the metrics they ' ve determined to be critical KPIs for their application ' s performance.

HTTP Request and Custom Actions are the two action types designed to integrate AppDynamics policy events with external alerting or event-management platforms.

An HTTP Request action sends an outbound request to a configured third-party endpoint when a policy is triggered. The analyst can specify the URL, HTTP method, authentication, headers, and event payload. This is commonly used with webhook-enabled alerting, incident-management, automation, and collaboration systems.

A Custom Action extends the Controller’s standard action framework through a custom action module. It is appropriate when the external platform requires specialized processing, a proprietary protocol, payload transformation, or integration logic that cannot be handled by a standard HTTP request.

Notifications primarily deliver native email or SMS messages. Diagnostics initiate troubleshooting activities such as diagnostic sessions or thread dumps, while Remediation performs corrective operations. Issue Tracking System Integrations are specifically intended for creating or updating work items in supported issue-management platforms rather than providing a general alerting integration mechanism.

Relevant CAAPA topics include Health Rules, Policies, Policy Actions, HTTP Request Actions, Custom Actions, Webhook Integration, and Third-Party Event Management.

AppDynamics imposes a limit on the number of Service Endpoints that can be registered per node to ensure manageable performance and overhead. The limit per node is set to 100 Service Endpoints, which is a balance between providing detailed monitoring and maintaining application performance.

The permission to enable snapshot archiving in AppDynamics typically falls under advanced operational capabilities, such as those categorized under " Agent Advanced Operation. " This permission allows users to archive transaction snapshots for long-term storage and analysis, which is essential for historical performance analysis and auditing purposes.

When an application team requests an increase in the Application Business Transaction limit for visibility purposes, it ' s crucial for the Performance Analyst to focus on the transactions that are currently exceeding the limit and understand why. This approach helps in identifying whether the limit is being reached due to genuinely essential transactions or if there are redundant, irrelevant, or improperly defined transactions contributing to the limit breach. By analyzing and rationalizing the transactions, the analyst can ensure that only valuable transactions are monitored, optimizing resource usage and maintaining effective observability without necessarily increasing the limit.

A split exit point is identified using dynamic application values. AppDynamics can evaluate runtime information associated with an exit call and use that value to divide a single exit-point definition into separately monitored backend destinations or logical exit points.

Dynamic values may be obtained from method arguments, object properties, return values, headers, or other runtime data exposed through the configured getter chain. For example, an application may use one shared client method to call several external services. Although the class and method remain constant, a dynamically supplied host name, service name, destination identifier, or URL can distinguish the actual backend being invoked. Splitting on that runtime value allows AppDynamics to display and measure each destination independently.

Static values do not change between invocations and therefore cannot meaningfully separate one exit-call destination from another. “Variable application values” is not the formal configuration term used for this feature, while Tetration values relate to a separate Cisco workload and security platform.

Relevant CAAPA Study Guide topics include Exit-Point Detection, Custom Exit Points, Split Exit Points, Dynamic Runtime Values, Getter Chains, Backend Identification, and Cross-Tier Correlation.

By default, an active health rule violation displayed on the Health Rules Violations page is updated at 30-minute intervals after the initial violation event is triggered. AppDynamics first evaluates the health-rule condition against the configured critical or warning criteria. When the condition remains true for the configured evaluation and wait period, the Controller opens a health rule violation event.

While that violation remains active, AppDynamics periodically updates its displayed status and associated event information. The default continuation-update interval is 30 minutes. The violation is subsequently closed when the monitored metric no longer satisfies the violation criteria for the required duration.

The wait time after violation determines how long a condition must persist before AppDynamics opens the violation; it does not define the ongoing update frequency. The page is also not limited to updating only when a new violation starts, nor must an existing violation close before updated information can be recorded.

Relevant CAAPA Study Guide topics include Health Rule Evaluation, Warning and Critical Conditions, Wait Time After Violation, Health Rule Violation Events, Violation Lifecycle, and Controller Event Updates.

A method invocation data collector is used because the required business value exists inside the Java application’s Checkout class rather than in the HTTP request.

The Performance Analyst configures the collector against the appropriate class and method, then identifies the value through a method argument, return value, object field, or getter chain. AppDynamics captures that checkout value when the configured method executes and associates it with the corresponding Business Transaction data. The collected value can subsequently be used for business analysis and aggregation, allowing stakeholders to report total or running checkout value over a selected time period.

A dashboard widget can visualize or aggregate data that AppDynamics already collects, but it cannot independently extract a value from Java code. An HTTP data collector is appropriate only when the required value is contained in request parameters, headers, cookies, session attributes, or other HTTP data. A REST export retrieves existing Controller data and therefore does not solve the initial instrumentation requirement.

Relevant CAAPA Study Guide topics include Method Invocation Data Collectors, Java Class and Method Instrumentation, Getter Chains, Business Data Collection, Transaction Analytics, and Custom Dashboard Visualization.

In environments where virtual machines are frequently created and destroyed, using the agent configuration properties -Dappdynamics.agent.reuse.nodeName and -Dappdynamics.agent.reuse.nodeName.prefix can be beneficial. These settings allow AppDynamics agents to reuse node names for newly created instances, facilitating consistent monitoring and tracking across dynamic environments. This approach helps maintain clarity in application topology and ensures that performance data remains coherent even as the underlying infrastructure changes.

A shared AppDynamics dashboard can be published through a shareable URL that allows viewers to access the dashboard without logging in to an AppDynamics account. This capability is intended for distributing operational or business-performance information to stakeholders who do not require full Controller access, such as support teams, management, or external display systems.

The dashboard owner controls whether the dashboard is shared and which information is exposed. Shared access is generally read-only, so unauthenticated viewers can examine the dashboard’s widgets and current data but cannot modify its configuration, create monitoring rules, or access unrelated areas of the Controller.

Administrator access is not required merely to view a shared dashboard. Likewise, authenticated AppDynamics access is not mandatory when the dashboard has been explicitly published for external or public viewing. Network restrictions may still apply at the organization, proxy, firewall, or Controller-hosting level, but they are deployment controls rather than an AppDynamics login requirement for the shared dashboard itself.

Relevant CAAPA Study Guide topics include Custom Dashboards, Dashboard Sharing, Shareable URLs, Read-Only Access, Controller Permissions, and Role-Based Access Control.

To post an AppDynamics event to a third-party collaboration tool, the Performance Analyst needs to select the " Make an HTTP Request " alert action. This action allows AppDynamics to send an HTTP request to a specified URL, which can be the endpoint provided by the third-party tool ' s API. This integration capability enables the automatic posting of events, alerts, and notifications from AppDynamics to collaboration tools, enhancing communication and response times to performance issues.

With Business Transaction Lock Down enabled, AppDynamics prevents automatically discovered traffic from registering additional Business Transactions. Newly observed requests that do not match an existing registered transaction are generally aggregated under the tier’s All Other Traffic transaction, protecting the Controller from uncontrolled Business Transaction growth.

To monitor the new web service as an explicitly named, unique Business Transaction, the Performance Analyst should create a Custom Transaction Match Rule. The rule can identify the service by its Web Service Name and Operation Name, providing deterministic matching and naming independently of automatic transaction discovery. Custom rules are the appropriate mechanism for intentionally introducing important transactions while maintaining lockdown governance.

Changing the automatic discovery rule does not overcome the purpose of lockdown because new automatically discovered transactions remain restricted. Live Preview assists with validating detection-rule behavior but is not the persistent configuration that defines the transaction. All Other Traffic provides aggregated visibility into unregistered traffic; it does not replace a precise custom detection rule.

Relevant CAAPA Study Guide topics include Business Transaction Lock Down, Custom Match Rules, Web-Service Entry Points, Transaction Naming, Automatic Discovery, and All Other Traffic.

Business Transaction Discovery Sessions are supported for Java and .NET applications. These sessions help a Performance Analyst identify candidate transaction entry points when automatic discovery does not detect a proprietary framework, background process, scheduled task, or other nonstandard execution path.

During a discovery session, the Application Agent observes executed application code and allows the analyst to browse relevant classes and methods. The selected method can then be used to create or refine a Custom Match Rule, establishing a new Business Transaction entry point with appropriate naming and scope.

Java and .NET agents provide the runtime instrumentation and class-method visibility required for this workflow. C++, PHP, and Node.js applications have their own supported monitoring and transaction-detection capabilities, but they do not use the Business Transaction Discovery Session feature referenced in this question.

Discovery sessions should be run for a controlled period while representative application traffic exercises the target code path. The resulting class and method information can then be reviewed before creating a permanent transaction detection rule.

Relevant CAAPA Study Guide topics include Business Transaction Discovery Sessions, Java Agent, .NET Agent, Class and Method Browsing, Custom Match Rules, Entry-Point Detection, and Transaction Naming.

To monitor end-to-end latency performance metrics, a Performance Analyst must first define the end-to-end latency transaction. This involves configuring the business transactions to include the necessary entry and exit points that capture the complete flow of the transaction, thereby enabling the measurement of the total latency.

If a Business Transaction stops being displayed on the Business Transaction Dashboard after continuous load, it could be due to the deletion of the Business Transaction Custom Match Rule. Custom Match Rules in AppDynamics are used to define custom business transactions based on specific criteria. If such a rule is deleted, transactions that were previously identified and displayed based on that rule may no longer be recognized as distinct business transactions, leading to their disappearance from the dashboard.

A Business Transaction must be defined when a discovered entry point initiates one or more asynchronous activities. The Business Transaction establishes the logical monitoring context for the original user request and enables AppDynamics to associate subsequently spawned asynchronous work with that request.

When asynchronous processing occurs, execution may continue on different threads, task executors, queues, or callback mechanisms after the initiating thread has completed or moved on. AppDynamics propagates the Business Transaction correlation context across these asynchronous boundaries so the resulting activity can be represented as part of the same end-to-end transaction. This allows the analyst to evaluate total response time, asynchronous segments, downstream calls, errors, and call-graph execution in the proper transaction context.

A Custom Endpoint is not required merely because asynchronous work is spawned. Asynchronous metrics and endpoint metrics are measurements generated from monitoring; they do not establish the identity or correlation boundary of the request.

Relevant CAAPA Study Guide topics include Business Transaction Discovery, Entry Points, Asynchronous Transaction Tracking, Thread Handoffs, Transaction Correlation, Call Graphs, and End-to-End Transaction Visibility.

The Business Transaction Discovery feature in AppDynamics allows users to identify new and potential business transactions directly within the Business Transaction Dashboard. This feature aids in the continuous monitoring and adaptation of the application ' s transaction tracking to changing business needs, ensuring comprehensive visibility. Users can also preview these identified transactions, assessing their relevance and impact on the application ' s performance before deciding to monitor them as official business transactions.

When a Performance Analyst drills into a call graph, AppDynamics exposes method-level execution details that identify where transaction processing time was consumed. The method name identifies the specific application method invoked within the transaction execution path. Method time in milliseconds shows how much time was attributed to that method, enabling the analyst to isolate expensive code paths, compare parent and child execution time, and determine whether latency originates in application code or a downstream dependency.

The call graph can also display Service Endpoints encountered during transaction processing. Service Endpoints represent independently monitored application services or methods and help the analyst understand how internal service execution contributes to the overall Business Transaction response time.

The Business Transaction name and user-experience classification—such as normal, slow, very slow, stalled, or error—are transaction-snapshot context rather than method-level call-graph drill-down data. They describe the transaction as a whole, while the call graph focuses on the execution sequence and timing of instrumented methods and service interactions.

Relevant CAAPA Study Guide topics include Transaction Snapshots, Call Graph Analysis, Method Execution Time, Service Endpoints, Code-Level Diagnostics, and Business Transaction Troubleshooting.

A relative metric path with a wildcard is used when a metric condition must be evaluated across multiple comparable entities, such as hardware resources, JVM memory pools, nodes, or other dynamically named metric branches.

A relative path is resolved in the context of each entity selected by the health rule or metric evaluation scope. Adding a wildcard allows AppDynamics to match multiple child metric paths rather than requiring one fixed, fully qualified metric location. This is particularly useful when memory-pool names, hardware instances, or resource identifiers differ between nodes or runtime environments.

An absolute metric path points to one exact location in the metric hierarchy and is therefore better suited to a single, explicitly identified metric. Although wildcard matching can be supported in metric configurations, the correct approach for evaluating equivalent metrics across multiple scoped entities is the relative-path model.

The Metric Browser supports hierarchical metric navigation, and wildcard-capable paths are used where dynamic or repeated entity structures must be addressed. Relevant CAAPA Study Guide topics include Metric Browser, Relative and Absolute Metric Paths, Wildcard Metric Selection, Health Rule Conditions, Hardware Resource Metrics, and JVM Memory Pool Monitoring.

If the Average Response Time is increasing after the release of a new marketing offer, seeing an increase in Calls per Minute could quickly help the Performance Analyst determine that users may not be critically impacted. This increase may indicate that despite the higher average response time, more users are engaging with the application, possibly due to interest generated by the marketing offer. It suggests that the system is handling more load, which could be a factor in the increased response time.

The custom exclude rule prevents the servlet request from being registered and monitored as a Business Transaction, while the Service Endpoint custom match rule independently instruments the matching URI as a Service Endpoint. AppDynamics therefore continues to collect Service Endpoint metrics, including average response time, calls per minute, and errors, allowing the analyst to monitor the service’s performance without consuming a Business Transaction registration.

The excluded request does not produce normal Business Transaction snapshots, so the analyst cannot rely on snapshot call graphs to inspect the Service Endpoint or its downstream exit calls. Exit-point visibility is normally obtained through Business Transaction snapshots and call graphs.

EUM correlation also depends on the server-side request being represented as a correlated Business Transaction. A standalone Service Endpoint does not replace that Business Transaction correlation path and therefore cannot provide equivalent browser or mobile EUM linkage.

Relevant CAAPA Study Guide topics include Service Endpoint Detection, Custom Service Endpoint Match Rules, Business Transaction Exclude Rules, Service Endpoint Metrics, Transaction Snapshots, Exit Calls, and EUM Correlation.

The default value pair for the setting " Collect up to ____ snapshots per minute for _____ minutes " in the configuration for Slow Transactions is 10, 10. This means that by default, the system is set to collect up to 10 snapshots per minute for a duration of 10 minutes during a diagnostic session.

Server Tagging in AppDynamics allows a Performance Analyst to compare and filter related servers by using custom metadata. This feature enables users to group and organize their servers based on criteria that make sense for their environment, such as role, location, environment type, or any other custom metadata.

When a Performance Analyst observes a significant decrease in an application ' s workload (calls/min), reviewing the " Top Business Transactions by Load " in the Application Dashboard can provide valuable insights. This feature allows the analyst to quickly identify which business transactions have experienced the most significant changes in load, potentially pinpointing the root cause of the overall workload decrease. It offers a focused view of the application ' s performance, highlighting areas that may require further investigation or immediate action.