The correct approach is to use the Query Debugger in AEM, which provides detailed insights into query performance, including query cost, traversal warnings, and which indexes are being used. The Explain Query tool is a lower-level utility but does not provide the same AEM-specific integration and insights as the Query Debugger. Updating Lucene indexes (Option C) might eventually be needed, but the first step is always to analyze query performance and confirm whether the issue is due to indexing. Adobe documentation emphasizes using the Query Debugger under /libs/granite/operations/content/diagnosistools/queryPerformance to identify query inefficiencies and missing index configurations before applying fixes.

In Adobe Experience Manager (AEM), editable templates are a key feature introduced in AEM 6.3 and enhanced in subsequent versions, including AEM as a Cloud Service. These templates allow authors to create and manage page templates dynamically through the Template Editor, unlike static templates that reside under /apps. Editable templates are stored in the CRX repository under the /conf directory, which is the designated location for configuration-related content, including templates and policies.

When a developer creates an editable template, such as home-template in the AEM application wknd, AEM automatically generates a specific node structure in the CRX repository under /conf. The structure follows a standardized hierarchy to store template configurations, policies, and associated metadata. The correct structure for an editable template is as follows:

/conf : The root node for configuration data in AEM, used to store project-specific configurations like editable templates.

wknd [sling:Folder] : A folder node representing the project or tenant (in this case, the wknd application).

settings [sling:Folder] : A subfolder that organizes WCM (Web Content Management) configurations.

wcm [cq:Page] : A node representing the Web Content Management configurations, typically stored as a cq:Page to align with AEM’s page structure.

templates [cq:Page] : A node that holds all editable templates for the project, stored as a cq:Page to allow for template metadata and properties.

home-template [cq:Template] : The actual template node, which is of type cq:Template. This node contains the template’s configuration, including its structure, initial content, and policies.

The node type for the template itself (home-template) is cq:Template, which defines it as an editable template that can be used to create pages. This distinguishes it from a cq:Page node, which is used for actual content pages or structural nodes like the templates parent node. The other options provided in the question are incorrect for the following reasons:

Option A : Incorrectly specifies the home-template node as cq:Page instead of cq:Template. Editable templates are always stored as cq:Template nodes.

Option C : Incorrectly places the structure directly under /wknd without the /conf root, which is not the standard location for editable templates.

Option D : Incorrectly places the structure under /apps, which is used for static templates and application code, not editable templates.

This structure ensures that editable templates are stored in a configuration scope that is separate from application code (/apps) and content (/content), allowing for better management and scalability, especially in multi-tenant environments like AEM as a Cloud Service.

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

From " Editable Templates " : " Editable templates allow authors to create and maintain templates from the UI. These templates are stored under /conf in the repository, typically in a structure like /conf/ < project > /settings/wcm/templates/ < template-name > . The template node itself is of type cq:Template. "

From " AEM Project Structure " : " Editable templates are stored under /conf/ < project-name > /settings/wcm/templates. Each template is a cq:Template node, and the parent templates node is a cq:Page. This structure separates configuration data from content and code. "

From " Template Editor " : " When a template is created via the Template Editor, AEM creates a node structure under /conf/ < tenant > /settings/wcm/templates/ < template-name > with the template node being of type cq:Template, which holds the template’s definition, policies, and initial content. "

Explanation (Adobe Docs Reference):

Editable templates + Policies : Editable templates allow developers to restrict which components are available by defining policies that control allowed components for layout containers.

Content Fragment Model validation : Developers can define validation rules (e.g., regex, required fields, min/max length) directly in the content fragment model.

Options A, C, and D are incorrect:

Field validation is not configured in editable templates (A is wrong).

Workflows are not used for enforcing component usage (C is wrong).

Dynamic templates are deprecated in favor of editable templates (D is wrong).

Adobe Documentation:

“Editable templates support defining policies to determine which components can be used in the layout container.”

— AEM Templates – Defining Policies

“Content Fragment Models can include validation rules to ensure data integrity, including regex patterns, length restrictions, and required fields.”

— AEM Content Fragment Models – Validation Rules

In multi-module AEM Maven projects, the all module is responsible for packaging and deploying all submodules. To ensure a new module is included during installation, it must be listed in the embeddeds section of the filevault-package-maven-plugin configuration inside the all module. This ensures the module is packaged into the final deployable ZIP and installed into AEM. Option A and B are incorrect because the maven-bundle-plugin manages OSGi bundle metadata, not multi-module embedding. Adobe’s official archetype documentation specifies that developers must add new modules to the embeddeds configuration for them to be recognized in the final deployment.

In AEM, fine-grained access control is managed using JCR Access Control Entries (ACEs). To grant access only to a specific node but exclude all child nodes, the correct approach is to set the rep:glob = " " property. This ensures that permissions apply strictly to the node itself and not recursively. Option B, rep:globs = " ** " , would apply access recursively to all descendants. Option C, rep:glob = " child " , is invalid and does not represent a valid configuration. Adobe recommends precise use of rep:glob patterns to restrict user access according to security requirements, ensuring least-privilege principles.