By default, when saving dialog values, AEM stores them as String types in the JCR unless a type hint is provided. To ensure a checkbox is stored as a Boolean, developers must add a hidden TypeHint field to the dialog. This informs Sling Post Servlet about the correct JCR type when persisting values. Option A, using a JCR Event Listener, is inefficient and adds unnecessary complexity. Option C, using a Switch, would still result in a String unless the TypeHint is specified. Adobe documentation specifies that TypeHint fields should be added whenever developers need precise control over how values are stored, especially for Boolean, Long, or Date properties.

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.

When unit testing a service that depends on JCR queries, the best practice is to use mocking frameworks (such as Mockito) to mock the Query and QueryResult objects. The purpose of a unit test is to isolate the service under test and not rely on a real JCR repository or SlingContext persistence layer, which moves testing into integration testing territory. By mocking the Query object and using the when(...).thenReturn(...) pattern, developers can control query results and validate how the service behaves under different scenarios. This ensures that the test runs quickly, without dependency on repository setup or external data. Option B is incorrect because currentResource() is used in Sling Model tests rather than for query-driven services. Option C with SlingContext and JCR_OAK would be used in integration or functional tests, not in lightweight unit tests. Adobe documentation highlights that JCR queries should be mocked in unit tests to ensure isolation and speed.

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.

In Adobe Experience Manager Dispatcher configuration, cache-related settings are defined inside the dispatcher.any configuration files located under /etc/httpd/conf.dispatcher.d/cache/. By default, the dispatcher module loads its cache rules from the file named _cache.any. This file specifies which resources should be cached, ignored, or invalidated.

From Adobe Documentation:

“Cache configuration is defined in the dispatcher.any configuration file, typically found in /etc/httpd/conf.dispatcher.d/cache/_cache.any.”

— Adobe AEM Dispatcher Documentation – Cache Configuration (AEMaaCS & AEM 6.5+)

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.

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

AEM package files follow a standard naming convention in CRX Package Manager :

< package-name > - < group-name > - < version > .zip

Thus, with the package name aem-package, group aem_group, and version 1.0, the correct package name is aem-package-aem_group-1.0.zip. Option B is invalid because group names and content paths are not combined in filenames. Option C omits the group name, making it incomplete. Adobe documentation emphasizes this naming convention for easier package identification and dependency management across environments.

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.

The Dispatcher should be configured to cache static pages like .html , but when query parameters are present (used for personalization, targeting, or dynamic rendering), the dispatcher must invalidate or bypass cache to prevent stale or incorrect content delivery.

Option A is correct → balances performance (cache static .html) and personalization (invalidate with query strings).

Option B is incorrect → POST requests should never be cached, as they modify content.

Option C is incorrect → disabling cache for all .html removes performance benefits.

Adobe Documentation:

“The dispatcher can be configured to cache .html responses while invalidating the cache when query string parameters are present. This ensures efficient caching while supporting personalization and dynamic content.”

— AEM Dispatcher Caching Guidelines