Adobe AD0-E137 Adobe Experience Manager Sites Developer Expert Exam Practice Test

When defining component style options in AEM, authors can select from pre-defined CSS classes by configuring them in the component’s cq:editConfig node under /cq:style. The correct properties are:

cq:styleClasses: Defines the list of CSS classes that authors can apply.

cq:styleLabel: Defines the label displayed in the authoring dialog for the style selection.

Options B, C, D are incorrect because they use invalid property names (cssClasses, styleLabel, cssStyles, cssLabel) which are not recognized by AEM.

From Adobe Documentation:

“Component styles can be defined using the cq:editConfig node. Authors can choose between style variations configured under cq:styleClasses with a descriptive cq:styleLabel.”

— AEM 6.5 – Defining Component Styles with cq:editConfig

— AEM Core Components – Style System

The RepoInit feature is the correct solution. RepoInit scripts allow developers to define repository initialization instructions in a declarative manner. With RepoInit, engineers can register namespaces, create folders, define service users, configure access control lists (ACLs), and create groups — all in one script. Option A, Ensure Authorizable, is limited to ensuring users or groups exist but does not handle namespaces or folder creation. Option C, OnDeploy Scripts, is not recommended for these tasks, as RepoInit is the standard, supported, and maintainable approach for repository initialization in AEM. Adobe documentation highlights RepoInit as the best practice for managing repository initialization in both AEM 6.5 and AEM as a Cloud Service.

The correct approach to display external API results using server-side rendering in AEM is to separate responsibilities across three layers. First, create an OSGi component that encapsulates the logic for making external API calls using an HTTP client. This ensures reusability and central management of integration code. Second, create a Sling Model that references this OSGi service. Sling Models provide a resource-adaptable layer that connects AEM components to backend services, making it easier to expose data to HTL scripts. Finally, bind this Sling Model to an AEM component, which displays the fetched data in server-rendered HTML. This is aligned with Adobe’s guidance that integration logic should be handled within OSGi services, with Sling Models bridging content and services for components. Options B and C incorrectly assign responsibilities to Servlets or components, which violates best practices for modularity.

In AEM as a Cloud Service, indexes must be defined and deployed as part of the project code base. The recommended approach is to extend or customize the out-of-the-box (OOTB) indexes by modifying the Oak index definitions and deploying them via Maven and Cloud Manager pipelines. This ensures that indexes are version-controlled, consistently deployed across all environments (Dev, Stage, Prod), and aligned with CI/CD practices. Option B is incorrect because replicating index packages via Package Manager is not supported in AEM as a Cloud Service. Option C is valid in scenarios where entirely new indexes are needed, but the question specifies that the index is based on existing search requirements. Adobe documentation emphasizes customizing existing indexes as the most efficient way to support project-specific queries.

When workflows require complex conditional logic or integration with external systems, Adobe recommends writing custom workflow process steps in Java. By implementing the WorkflowProcess interface, developers can evaluate metadata dynamically and invoke APIs or services as needed. Option A is too limited because out-of-the-box workflow steps support simple operations but cannot manage advanced branching or integrations. Option C is not suitable because content fragments are intended for structured content authoring, not for managing asset workflows. Adobe’s documentation states that workflows should remain modular, with custom steps encapsulating business-specific logic, while the Workflow Model defines the process flow. This ensures extensibility, testability, and clean separation between workflow orchestration and implementation logic.

The Retry Delay setting in a replication agent specifies the interval (in milliseconds) to wait before retrying a failed replication request. This ensures that temporary network or system issues don’t permanently block replication, as the agent will automatically attempt to resend content at the configured delay interval.

From Adobe Documentation:

“Retry Delay: The time (in milliseconds) to wait before attempting to retry a failed replication. This helps ensure that replication requests are retried at regular intervals if initial delivery fails.”

— Adobe AEM 6.5 & AEMaaCS – Replication Agent Configuration

Explanation (Adobe Docs Reference):

In Adobe Experience Manager (AEM), the SPA Editor enables the development of Single Page Applications (SPAs) that integrate with AEM’s content management capabilities. SPA components in AEM are typically React or Angular components mapped to AEM components, and their data is exposed to the SPA via JSON through the Sling Model Exporter framework. The ComponentExporter interface, part of the com.adobe.cq.export.json package, is used to define how AEM components are serialized into JSON for consumption by the SPA. By default, AEM provides a standard exporter (via the Sling Model Exporter) that serializes component data based on the Sling Model’s annotations and properties. However, developers can override this default exporter for specific components to customize the JSON output, such as adding, removing, or modifying fields.

The question specifies that the developer is creating a set of SPA components, where half do not require a custom component exporter (i.e., they can use the default exporter), and the other half need a custom exporter to override the default behavior. Let’s analyze the options to determine the correct approach:

Analysis of Options:

Option A: Implement ImplementationPicker service

The ImplementationPicker interface (from com.adobe.cq.wcm.core.components.util) is used in AEM’s Core Components to dynamically select the implementation of a component based on specific conditions, such as resource type or request context. It is not related to the Sling Model Exporter or JSON serialization for SPA components. Implementing an ImplementationPicker service would be relevant for selecting different component implementations (e.g., different HTL scripts or Java classes) but does not address the need to customize JSON export for SPA components. This option is incorrect.

Option B: Implement ComponentExporter service

The ComponentExporter interface is designed for SPA integration in AEM. When a Sling Model implements ComponentExporter, it can be serialized into JSON by the Sling Model Exporter, which is used by the SPA Editor to provide component data to the front-end SPA (React or Angular). To override the default exporter, a developer creates a Sling Model for each SPA component that requires customization, annotates it with @Model (specifying resourceType and exporters), and implements ComponentExporter. The model can then define custom methods or annotations (e.g., @JsonProperty, @ValueMapValue) to control the JSON output. For the components that do not require a custom exporter, the default Sling Model Exporter behavior (provided by AEM or Core Components) can be used without implementing ComponentExporter. This approach perfectly aligns with the requirement to override the default exporter for only half of the components. This option is correct.

Option C: Implement FallbackComponentImpl service

There is no such thing as a FallbackComponentImpl service in AEM or its SPA Editor framework. This appears to be a fictitious or misleading option. AEM’s SPA Editor and Sling Model Exporter do not use a “fallback” service for JSON export customization. Instead, customization is achieved through the ComponentExporter interface or by extending existing exporters. This option is incorrect.

Correct Implementation:

To meet the goal, the developer should:

For components that do not require a custom exporter, rely on the default Sling Model Exporter behavior. These components can use standard Sling Models (or Core Components) that are automatically serialized into JSON based on their properties and annotations.

For components requiring a custom exporter, create Sling Models that implement the ComponentExporter interface and annotate them with @Model (from org.apache.sling.models.annotations) and @Exporter (from org.apache.sling.models.annotations). For example:

import com.adobe.cq.export.json.ComponentExporter;

import org.apache.sling.api.SlingHttpServletRequest;

import org.apache.sling.models.annotations.Model;

import org.apache.sling.models.annotations.Exporter;

import org.apache.sling.models.annotations.injectorspecific.ValueMapValue;

import com.fasterxml.jackson.annotation.JsonProperty;

@Model(adaptables = SlingHttpServletRequest.class,

adapters = {ComponentExporter.class},

resourceType = "wknd/components/customcomponent",

exporters = @Exporter(name = "jackson", extensions = "json"))

public class CustomComponentModel implements ComponentExporter {

@ValueMapValue

private String customField;

@JsonProperty("renamedField")

The @Model annotation specifies that the class is a Sling Model adaptable from a SlingHttpServletRequest and implements ComponentExporter.

The @Exporter annotation registers the model with the Sling Model Exporter for JSON output (using Jackson).

The getExportedType() method, required by ComponentExporter, returns the resource type, which is used by the SPA to identify the component.

Custom logic (e.g., toUpperCase()) or annotations like @JsonProperty can be used to modify the JSON output.

Ensure the SPA Editor is configured correctly in AEM (e.g., the SPA project is set up with proper page templates and policies) to map these components to their front-end counterparts.

Why Option B is Correct:

Implementing ComponentExporter allows the developer to define custom Sling Models for the components that need a customized JSON output, overriding the default exporter’s behavior.

For the other half of the components, the default exporter (provided by AEM or Core Components) can be used without additional implementation.

This approach leverages AEM’s SPA Editor and Sling Model Exporter framework, which is specifically designed for exposing AEM component data to SPAs via JSON.

Exact Extracts from Adobe Experience Manager (AEM) Sites Developer Documents:

From "SPA Editor - Developing SPAs for AEM": "AEM components, which are used within the SPA Editor, must implement the ComponentExporter interface to be serialized correctly into the JSON format expected by the SPA. This interface allows developers to customize the JSON export of components for SPA integration."

From "Sling Model Exporter": "The Sling Model Exporter framework allows Sling Models to be exported as JSON for SPA integration. By implementing ComponentExporter and annotating with @Exporter(name = 'jackson', extensions = 'json'), developers can control the JSON output of their components."

From "AEM SPA Editor and React/Angular": "For custom components requiring specific JSON structures, implement a Sling Model with ComponentExporter and define custom getters to shape the JSON output. Components without custom exporters can rely on the default JSON serialization provided by AEM."

Explanation (Adobe Docs Reference):

Unit tests for Sling Models using wcm.io AEM Mocks (AemContext) require test content to be loaded into the mock JCR repository. This is usually done with:

ctx.load().json("/path/to/test-content.json", "/content");

Without loading node data, ctx.currentResource("/content/bar") won’t resolve anything, causing adaptTo(Flarp.class) to return null.

A is wrong: AemContext is correct for Sling Models in AEM.

B is wrong: @Rule applies to JUnit4, but the test uses JUnit5 with @ExtendWith.

C is correct: Loading JSON test content is required.

Adobe/WCM.IO Documentation:

“Use context.load().json() to load test content into the JCR repository for unit tests. Then set context.currentResource(path) to adapt resources to Sling Models.”

— wcm.io AEM Mocks Documentation

Two important weekly maintenance tasks for repository health are:

Datastore Garbage Collection (A): Cleans up unreferenced binaries in the datastore, preventing unnecessary growth in storage size.

Online Revision Cleanup (D): Reclaims space in the segment store by compacting revisions and removing obsolete data.

Option B, Clientlib Dumps, does not affect repository size. Option C, Version Purge, should be scheduled daily rather than weekly for continuous health. Adobe’s official guidelines recommend combining datastore GC with revision cleanup to prevent segment store bloat and performance degradation, ensuring repositories remain lean and optimized.

To optimize queries against DAM assets with custom properties, developers must extend the existing damAssetLucene index. The correct method is to add the custom property under:

oak:index/damAssetLucene/indexRules/dam:Asset/properties. This ensures that the property is indexed for all assets and avoids traversal queries. Option B refers to a non-existent lucene index path, and Option C incorrectly suggests adding a property value (Hello) instead of the property name. Adobe’s indexing guidelines specify that extending existing Lucene indexes such as damAssetLucene is the standard approach for asset-related queries. This ensures queries remain efficient, scalable, and compatible across environments.

The correct HTL syntax combines the page path and the suffix in a structured format where the final .html extension appears at the end of the generated URL. In AEM, links must resolve to valid Sling resources that end in .html for pages, and suffixes can be appended before the extension. Option B correctly creates the path /content/testsite/en/page1/product/test1.html, which is a valid and Sling-resolvable path. Option A incorrectly places .html too early, producing an invalid URL that AEM cannot resolve. Option C inverts the intended relationship between the path and suffix. Adobe documentation for HTL and URL construction highlights that Sling requires .html as the standard extension for page rendering, and suffixes should precede this extension.

In AEM’s Template Editor, there are multiple modes that allow template authors to configure different aspects of templates. The Structure mode defines static and editable areas in templates. The Page Policy allows defining rules such as which components are available for use. However, the Layout mode is specifically designed for defining grid settings for different devices. With Layout mode, template authors can configure responsive layouts and grid behavior across breakpoints such as desktop, tablet, and mobile. This ensures consistent responsive design and adaptability across devices. Adobe documentation specifies that “Layout mode allows authors to configure responsive grid layouts for different breakpoints, ensuring that pages render appropriately on devices of varying screen sizes.” This mode is essential for enabling adaptive and responsive designs in AEM projects. Options B and C do not allow for device-specific grid settings and thus are not correct.

Run mode-specific configurations in AEM follow a strict naming convention under the osgiconfig folder. The folder structure defines both the run mode (author or publish) and the environment (e.g., dev, stage, uat, prod). For UAT author environments, the correct structure is config.author.uat. Option C follows this convention correctly. Option A and B use incorrect naming patterns, which would prevent AEM from loading the configuration under the desired run mode. Adobe emphasizes the importance of placing OSGi configs in the correct folder paths within the ui.apps project or ui.config project depending on deployment structure.

Explanation (Adobe Docs Reference):

The correct OSGi Declarative Services (DS) implementation in AEM:

Must use implements (not extends).

Must register the service interface (SimpleService.class).

Should return an implementation for getMessage().

Option D is the correct implementation.

Options A, B, C are wrong because:

A incorrectly uses extends.

B and C register the wrong service type (MySimpleService).

Adobe Documentation:

“An OSGi service implementation must implement its interface and be annotated with @Component(service=Interface.class) to register the service.”

— OSGi Services in AEM

Explanation (Adobe Docs Reference):

In AEM SPA Editor, the MapTo function is used in the React (or Angular) component to map a frontend component to its corresponding AEM component resource type (Sling Model). This ensures data from the Sling Model is properly bound to the SPA component.

Correct: React component implements MapTo with the AEM component resource type.

Incorrect: The AEM Component or Sling Model itself does not implement MapTo.

Adobe Documentation:

“SPA components must call MapTo in the JavaScript app to map a frontend component to an AEM component resource type. This enables the Sling Model data to be injected into the SPA component.”

— AEM SPA Editor – MapTo Function