AD0-E137 Adobe Experience Manager Sites Developer Expert Question and Answers

Explanation (Adobe Docs Reference):

The SAML Authentication Handler in AEM requires the following key properties:

path: Defines the content path where this handler applies (here /content/siteB).

idpUrl: The Identity Provider’s SAML endpoint (here https://www.idpB.com).

Other properties like serviceProviderEntityId and assertionConsumerServiceURL are also required in a real-world setup but the correct basic mapping in this scenario is option B.

Adobe Documentation:

“The SAML authentication handler is configured by setting path to the protected resource root and idpUrl to the Identity Provider endpoint.”

— Adobe AEM 6.5 – SAML Authentication Handler

The error clearly indicates that the bundle is exporting a package without specifying a version. In OSGi, best practices dictate that every exported package must declare a version in the Export-Package manifest header. Furthermore, consumers of these packages must use Import-Package with version ranges to ensure compatibility and avoid conflicts during runtime. The absence of a version means other bundles cannot reliably resolve the correct package version, leading to potential deployment issues. Option A and D are general dependency resolution checks but do not address the specific missing version. Option B relates to conflicts with AEM-provided bundles, which is not the cause here. The correct fix is to add a version to the Export-Package declaration and ensure imports define version ranges. Adobe explicitly highlights this as part of OSGi bundle troubleshooting.

Explanation (Adobe Docs Reference):

Replication agents in AEM are responsible for transferring content and digital assets from the author instance to the publish instance (or to other targets like Dispatcher flush agents). This ensures that authored and approved content becomes available on the public site.

Options B and C are incorrect:

User permissions are not replicated by agents; they are managed by user synchronization.

Core Components are provided via Maven dependencies and not transferred via replication agents.

Adobe Documentation:

“Replication agents are central to AEM; they are used to publish (activate) content from an author to a publish environment, or to clear content from the dispatcher cache.”

— AEM Replication Agents

Explanation (Adobe Docs Reference):

AEM provides Generic Analytics Snippet functionality to allow marketing/analytics teams to manage third-party tracking scripts directly through the AEM UI, without needing a development release cycle. This enables non-developers to add or update scripts (e.g., analytics tags, marketing pixels) safely.

Option A is incorrect: Hardcoding the script in HTL means dev releases are required for every change.

Option B is incorrect: Page policies control design configurations and allowed components, not scripts.

Option C is correct: Generic Analytics Snippet is designed for this scenario.

Adobe Documentation:

“AEM provides a generic analytics snippet component that allows administrators to add and manage third-party tracking codes outside of the development cycle.”

— AEM Sites – Generic Analytics Snippet

The recommended way to generate a new AEM project is by using the official Adobe AEM Maven Archetype. Developers must specify the correct groupId (com.adobe.aem) and artifactId (aem-project-archetype). The archetypeVersion should match the latest stable archetype version (e.g., 50 for AEM 6.5). The groupId of the project should be set to the organization’s package, in this case com.mysite. The appId defines the project name and should match the intended application (mysite). The version is defined as 2.0 to represent the project version, while aemVersion=6.5 ensures compatibility with AEM 6.5. Option A is invalid because the archetype groupId is incorrect and the values are mismatched. Option C contains placeholders and an invalid groupId. Adobe’s official documentation for generating projects specifies option B as the valid approach.

Explanation (Adobe Docs Reference):

When configuring SAML SSO with AEM, the dispatcher must allow POST requests to the saml_login endpoint. If blocked, AEM redirects endlessly back to the IDP. This is done by allowing the POST request in filters.any.

Adobe Documentation:

“For SAML authentication to work with AEM behind a Dispatcher, you must configure the dispatcher filter to allow POST requests to /saml_login. Otherwise, authentication attempts will loop infinitely.”

— AEM Dispatcher and SAML Authentication Configuration

In Dispatcher configuration, request filtering is handled through the filters.any file. To deny access to specific content types or formats (like .json and .xml) for certain paths, the configuration must explicitly match both the extension and the path using correct syntax. The valid approach uses:

/0001 { /type "deny" /extension "(xml|json)" /path "(/path2|/path3)/*" }

Options A and B contain syntax errors. Option A incorrectly uses JSON/* instead of paths, and Option B mixes array-style brackets instead of regex or path expressions. Option C follows the correct pattern of specifying deny rules with /extension and /path. Adobe recommends always explicitly denying unwanted selectors or extensions to prevent exposure of sensitive content through JSON or XML requests.

In AEM as a Cloud Service, dedicated preview service endpoints are configured under publish run modes. The correct configuration folder for a UAT preview service is config.publish.uat within the ui.config project. Option A incorrectly places the configuration under author run mode, which is unrelated to preview endpoints. Option C misorders the naming convention, using config.uat.author instead of the proper config.publish.uat. Adobe’s guidance specifies that preview service configuration is a publish-tier responsibility, requiring config.publish. folders in the configuration project.

In AEM, multi-site management allows centralized content updates to be pushed across different localized or departmental sites. The “Partial” option on the rollout configuration ensures that only specific components or regions designated for shared updates are synchronized, while leaving local content intact. This fits the described requirement where a portion of each school’s homepage must receive university updates without affecting school-specific content. Option A, Experience Fragments, could be used but are better suited for shared fragments of design/content, not controlled rollout scenarios. Option C requires manual inheritance restoration per page, which is inefficient. Option D, implementing custom rollout logic, is not needed when the built-in “Partial Rollout” option fulfills the requirement. Adobe emphasizes using partial rollout in multi-site configurations to balance central control with localized autonomy.

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."

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.

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.