Adobe Experience Manager Sites Developer Professional Questions and Answers
A developer needs to render ‘Hello World’ only when in edit mode.
Which approach should be used?
Options:
< p data-sly-test="${wcm.edit}" > Hello World < /p >
< p data-sly-test="${wcmmode.editor}" > Hello World < /p >
< p data-sly-test="${wcmmode.edit}" > Hello World < /p >
Answer:
CExplanation:
Comprehensive Explanation
Adobe Experience Manager provides the wcmmode object within HTL to identify the current Web Content Management rendering mode.
The wcmmode.edit property evaluates to true when a page is rendered in AEM's Edit mode. This enables developers to conditionally display authoring-specific markup without including that markup in normal published-page output.
The data-sly-test block statement evaluates a Boolean expression and renders its host element only when the expression is true.
The correct implementation is:
< p data-sly-test="${wcmmode.edit}" >
Hello World
< /p >
When an author opens the page in Edit mode, the paragraph is rendered. In other modes where wcmmode.edit evaluates to false, the paragraph is omitted.
Option A is incorrect because wcm.edit is not the documented HTL property for detecting the current authoring mode.
Option B is incorrect because wcmmode.editor is not the recognized mode property.
Adobe also documents wcmmode.preview for conditions that must apply specifically to Preview mode.
A common practical application involves displaying component placeholders when a component has no configured content. Such placeholders help authors identify and select components that would otherwise appear empty.
The wcmmode.edit condition is therefore the correct mechanism for rendering content exclusively in Edit mode.
Official Adobe Reference: Adobe Experience Manager Components — The Basics, Component Placeholders; Components Reference Guide — Authoring Mode.
A developer needs to use AEM Core Components in production mode, without sample content. The developer wants to do so without having to download and install the Core Components before using them.
Which AEM product should the developer use?
Options:
AEM as a Cloud Service
AEM as an Adobe Managed Service
AEM Version 6.3
Answer:
AExplanation:
Comprehensive Explanation
Adobe Experience Manager as a Cloud Service includes AEM Core Components as part of the managed platform, eliminating the requirement for developers to install the Core Components package manually.
Core Components provide standardized, extensible implementations of common website functionality, including text, images, titles, navigation, containers, and other presentation components.
Adobe maintains the Core Components within AEM as a Cloud Service and provides compatible component versions as part of platform updates.
In contrast, traditional AEM 6.5 deployments and Adobe Managed Services environments may require Core Components to be included as application dependencies or installed as part of the deployment process.
Option B is therefore not the most appropriate choice because Adobe Managed Services environments do not provide the same automatic Core Components availability model as AEM as a Cloud Service.
Option C is incorrect because AEM 6.3 predates the modern Core Components architecture supported by current AEM implementations.
The requirement to avoid sample content is also compatible with AEM as a Cloud Service. Developers can configure their AEM project without deploying optional demonstration content.
One important distinction remains: although Core Components are installed automatically, project developers must still configure their availability through appropriate proxy components, editable templates, and content policies.
Official Adobe Reference: Core Components Introduction — System Requirements and Cloud Service Availability; AEM Project Archetype.
An AEM Developer is responsible for creating a French version of an e-commerce site for several French-speaking African countries, including Chad, Ivory Coast, and Senegal.
What are the correct steps for implementing the sites with localized content?
Options:
Select AEM Multi-Site Manager and then use a Primary English version of pages to create French versions for Chad, Ivory Coast and Senegal
Select AEM Multi-Site Manager and then use a Primary French version of pages to create French versions for Chad, Ivory Coast and Senegal
Use Multi-Site Manager to create live copy of site templates then use separate French version for Chad, Ivory Coast and Senegal
Use local content authors to create the content for the local sites
Answer:
BExplanation:
Comprehensive Explanation
Adobe Experience Manager Multi Site Manager (MSM) enables organizations to maintain a centrally managed content source while distributing localized variations across multiple regional websites.
For this scenario, the appropriate implementation is to establish a primary French-language site and create Live Copies for Chad, Ivory Coast, and Senegal.
The primary French site serves as the content source, while individual country sites inherit common information through MSM Live Copy relationships. Rollout configurations determine when and how changes are synchronized between the source and regional destinations.
Each country can maintain localized information, including currency, shipping conditions, payment methods, promotional offers, and country-specific regulatory disclosures. Inheritance can be suspended where localized content must differ from the central version.
Option A is less appropriate because MSM does not perform language translation itself. Adobe recommends using translated language masters as sources for regional sites that share the same language.
Option C incorrectly emphasizes copying templates rather than managing Live Copies of content pages. Option D creates unnecessary duplication and weakens centralized content governance.
Using a French language master therefore provides consistent content management while preserving the flexibility required for country-specific localization.
Official Adobe Reference: Multi Site Manager and Translation; Reusing Content: Multi Site Manager and Live Copy.
An Adobe Experience Manager (AEM) developer is working on an AEM Sites project. Content authors report that one specific page takes too long to load and occasionally times out.
Which log file should be examined first to identify the potential cause of this issue?
Options:
Audit Log
Error Log
Dispatcher Log
Access Log
Answer:
BExplanation:
Comprehensive Explanation
When an AEM Sites page experiences unusually long loading times or intermittent timeouts, examining the application error log is an appropriate initial diagnostic step among the available choices.
The AEM error.log records exceptions, warnings, component-rendering failures, repository-query problems, and application-level errors that may explain why a particular page is failing or taking too long to render.
For example, a defective Sling Model, expensive repository query, unavailable backend integration, or component exception may generate log entries identifying the affected Java class or service.
Option A is incorrect because the Audit Log records content-management and administrative actions rather than diagnosing application execution failures.
Option C is useful when the problem involves Dispatcher caching, connection failures, or communication with AEM Publish instances. However, it is not necessarily the most direct source of application-level diagnostic information.
Option D provides request-access information but generally does not expose the internal application exceptions responsible for page failures.
Important qualification: Adobe specifically identifies request.log as the starting point for measuring slow AEM requests. That option is missing from this question. Adobe also recommends reviewing error.log and access.log when troubleshooting slow or unresponsive pages.
Therefore, B is the best available answer for investigating potential application-level causes, but the question does not have a universally correct first log without additional diagnostic context.
Official Adobe Reference: Troubleshooting Slow Response and Unresponsive Pages in AEM 6.5; How to Analyze Common Critical AEM Issues.
A developer needs to customize a Core Component.
Which property must be configured in the new component to accomplish this?
Options:
sling:resourceSuperType
sling:superResourceType
sling:resourceType
Answer:
AExplanation:
Comprehensive Explanation
Adobe Experience Manager recommends customizing Core Components through the proxy component pattern, which relies on the Sling resource type inheritance mechanism.
The sling:resourceSuperType property establishes an inheritance relationship between a project-specific component and an existing Core Component.
For example, a custom title component can extend an AEM Core Title Component by defining the following property:
sling:resourceSuperType="core/wcm/components/title/v3/title"
With this configuration, the custom component can inherit relevant functionality, rendering scripts, and dialog definitions while selectively overriding the elements required by the project.
The approach also works with the Sling Resource Merger, allowing developers to customize component dialogs without copying their complete definitions.
Option B is incorrect because sling:superResourceType is not the recognized property used to establish Sling resource inheritance.
Option C, sling:resourceType , identifies the resource type used to render a content resource. It does not itself establish the component inheritance relationship described in the question.
Adobe recommends proxy components instead of directly modifying Core Component implementations. This minimizes duplication and supports more maintainable upgrades, although customizations must still be tested when Core Component versions change.
The correct configuration property is therefore sling:resourceSuperType .
Official Adobe Reference: Customizing Core Components — Customization Patterns; Using Core Components — Create Proxy Components.
A developer reviews an AEM start script on the server and finds that the CQ_JVM_OPTS parameter is set to:
"-agentlib:jdwp=transport=dt_socket,address=8000,server=y,suspend=n"
How does this value affect startup of the AEM instance?
Options:
AEM instance will temporarily be suspended, and it will not be able to start
AEM instance will run in the debug mode
AEM instance will start in the publish mode
Answer:
BExplanation:
Comprehensive Explanation
The -agentlib:jdwp Java Virtual Machine parameter activates the Java Debug Wire Protocol (JDWP), enabling a debugger to connect to a running Java process.
In Adobe Experience Manager, this configuration is commonly used when debugging Java code through an IDE such as Eclipse or IntelliJ IDEA.
The parameter transport=dt_socket specifies socket-based communication between the JVM and debugging client.
The address=8000 setting identifies the port used for debugger connections, while server=y instructs the JVM to listen for incoming debugger connections.
The suspend=n setting is particularly important because it allows the AEM instance to continue starting without waiting for a debugger to attach.
Option A is incorrect because suspending startup would require suspend=y . Even then, startup would wait for a debugger rather than necessarily fail.
Option C is incorrect because the debug-agent settings do not determine the AEM instance's Author or Publish run mode.
Option B correctly identifies that the instance starts with remote debugging enabled.
Technical distinction: Remote JVM debugging is different from setting the AEM application log level to DEBUG . The JDWP parameter enables debugger attachment, breakpoints, and Java execution inspection.
Adobe recommends avoiding unnecessary remote debugging in production because it can introduce performance and security risks.
Official Adobe Reference: How to Debug an AEM App Using Eclipse — Add the Remote Debugging JVM Parameter.
A developer is troubleshooting a component in AEMaaCS and needs to compare its properties in the development environment with those in the production environment.
Which action should the developer take next to compare the two environments?
Options:
Check the log files for both environments
Check the Status of the Components in the Developer Console for both environments
Check the Repository Browser for both environments
Answer:
CExplanation:
Comprehensive Explanation
Adobe Experience Manager as a Cloud Service provides the Repository Browser as a diagnostic tool for examining repository resources and their stored properties across different environments.
The Repository Browser offers read-only access to the content structure of AEM environments, including Development, Stage, and Production.
To compare component properties, the developer accesses the AEM Developer Console through Cloud Manager and opens the Repository Browser for the appropriate environment and service tier.
The developer can navigate to the component's repository resource and inspect its stored properties, including sling:resourceType , component-specific configuration values, and other relevant JCR properties.
The same procedure can then be performed in the Production environment to identify differences.
Option A is incorrect because log files primarily contain execution and diagnostic messages rather than providing a complete view of stored component properties.
Option B is incorrect because the Developer Console's component-status information generally relates to OSGi components and runtime services, not the repository properties of an authored page component.
Option C directly supports the comparison required in the question.
Adobe documents the Repository Browser as a read-only tool accessible through the Developer Console. This design enables production troubleshooting without allowing developers to modify repository content.
Official Adobe Reference: Repository Browser — AEM as a Cloud Service; Debugging AEM as a Cloud Service with Repository Browser.
A developer has created a custom workflow model. When this custom workflow model is used on multiple assets/pages, a separate workflow instance is started for each asset/page.
Which property can be enabled to start one workflow instance when multiple assets/pages are selected?
Options:
Transient Workflow
Multi Resource Enable
Multi Resource Support
Answer:
CExplanation:
Comprehensive Explanation
Adobe Experience Manager supports custom components within editable templates by combining component definitions, template structure, content policies, and HTL resource rendering.
A developer first creates a custom component, normally under the project's /apps hierarchy, and defines the relevant component properties, dialogs, Sling Models, and rendering scripts.
The component can then be enabled through the editable template's content policy. Specifically, template authors configure allowed components in the policy associated with the relevant layout container.
HTL provides the data-sly-resource statement for including and rendering another resource within a component's output. Developers can use this statement when a component must be rendered explicitly through an HTL script.
Option A is incorrect because cq:include is associated with JSP-based component implementations rather than the recommended HTL approach.
Option B is incorrect because manually editing template nodes in CRXDE Lite is not the standard method for incorporating components into editable templates.
Option D is incorrect because custom components must be properly defined and made available to the relevant template containers.
Technical qualification: Option C uses the legacy expression design mode. Modern editable templates use the Template Editor's Structure mode and Content Policies. Moreover, data-sly-resource is not mandatory when a component is added directly through the Template Editor. Therefore, C is the closest intended answer, not a fully precise implementation procedure.
Official Adobe Reference: Templates to Create Pages That Are Editable with the Page Editor; HTL Resource Statement and AEM Component Rendering.
A front-end developer working on an AEM SPA project cannot view the property that should be exposed in the JSON for a newly created component, which was then added to the homepage (page-name.html).
Which option would provide information about whether the required property is exposed by the Sling Model?
Options:
[homepage-path]/page-name.model.json
[homepage-path]/sling.json
[homepage-path]/sling-model.json
Answer:
AExplanation:
Comprehensive Explanation
Adobe Experience Manager supports exposing structured component data through the Sling Model Exporter, which serializes Sling Model properties into JSON representations.
In an AEM Single Page Application (SPA) implementation, the frontend application consumes exported component data to render the user interface.
The .model.json selector provides access to the JSON representation generated by the Sling Model Exporter.
For example, a homepage located at /content/mysite/en/home.html can expose its exported model through:
/content/mysite/en/home.model.json
The developer can inspect this response to determine whether the custom component and its expected property are included in the exported model.
Option A correctly uses the .model.json selector.
Option B is incorrect because /sling.json is not the documented endpoint for the page's Sling Model Exporter representation.
Option C is incorrect because /sling-model.json does not follow the required selector structure.
If the property is absent, the developer should inspect the Sling Model's exported getters, annotations, implementation, component resource type, and the frontend component mapping.
The developer must also confirm that the relevant component is present in the page model and that the exported property is not explicitly excluded from JSON serialization.
This diagnostic method allows the frontend and backend implementations to be evaluated independently.
Official Adobe Reference: Sling Model Exporter — JSON Serialization; AEM SPA Editor and Model Exporter.
A developer needs to enable asynchronous indexing of multiple properties.
Which type of index should the developer use?
Options:
Ordered
Lucene
Property
Answer:
BExplanation:
Comprehensive Explanation
A Lucene index is the appropriate choice for asynchronously indexing multiple properties in Adobe Experience Manager.
AEM uses Apache Jackrabbit Oak as its repository implementation. Oak supports several index types, but Lucene indexes are particularly suitable for complex queries involving multiple properties, full-text searches, and structured content filtering.
A Lucene index is defined under /oak:index with an index definition specifying its indexed properties, applicable node types, and operational settings. Asynchronous indexing can be enabled through the async property, allowing repository changes to be processed independently of the original content-writing transaction.
This architecture reduces the overhead associated with maintaining complex indexes during content modifications. However, asynchronous indexes are eventually consistent, meaning that recently committed changes may not immediately appear in query results.
Option A is unsuitable because the historical Ordered index is not the recommended mechanism for modern AEM indexing requirements. Option C refers to a Property index, which is generally appropriate for simpler property-based equality queries rather than complex asynchronous indexing.
Adobe recommends Lucene-based indexes for custom indexing requirements, with carefully defined index rules and property definitions to maintain query efficiency.
Official Adobe Reference: Indexing Best Practices in AEM — Lucene Index Definitions and Asynchronous Indexing.
A developer needs to be able to run the following query:

Which two additions to the index are required?
Choose two
Options:
status property with propertyIndex = false
nt:base aggregate
status property with propertyIndex = true
nt:base index rule
Answer:
C, DExplanation:
Comprehensive Explanation
The exhibit contains a JCR-SQL2 query that selects repository nodes of type nt:base where the status property equals STARTED .
To support this query efficiently through a Lucene index, the index definition must include an applicable node-type rule and a property definition capable of evaluating the equality restriction.
Option D provides the required nt:base index rule. Because the query operates against nt:base , the index must support the relevant node types rather than restricting its definition to an incompatible resource type.
Option C enables property indexing for status by setting propertyIndex=true . This tells the Lucene index to maintain property values suitable for query constraints such as equality comparisons.
Option A is incorrect because propertyIndex=false does not enable the required property-based lookup.
Option B is incorrect because aggregation is used principally to incorporate child-node content into a parent node's index representation, especially for full-text scenarios. It is not required for this direct property comparison.
An appropriately defined Lucene index can therefore support the query using the nt:base index rule and the indexed status property.
Implementation note: These are the necessary additions among the supplied choices, assuming a suitable Lucene index already exists. The complete index also needs appropriate index-definition properties, and production indexing should avoid unnecessarily broad repository scans.
Official Adobe Reference: Content Search and Indexing — Lucene Index Definitions; Oak Queries and Indexing — Lucene Property Index.
A developer has enabled log-file rotation.
Why is this process important for managing log files?
Choose three
Options:
It deletes previous log files.
It limits the size of the log file.
It reduces disk space usage.
Answer:
A, B, CExplanation:
Comprehensive Explanation
Log-file rotation is an operational mechanism used in Adobe Experience Manager to prevent continuously growing log files from consuming excessive filesystem capacity.
AEM uses the Apache Sling logging infrastructure, which supports configurable rotation policies based on maximum file size or elapsed time.
Option B represents a principal benefit of size-based rotation. When the active log file reaches its configured threshold, the logging system rotates it and creates a new active log file.
Option C describes the storage-management benefit when rotation is combined with a suitable retention policy. By limiting the number of historical log files retained, administrators can prevent uncontrolled accumulation of diagnostic data.
Option A requires qualification. Rotation does not necessarily delete all previous log files. Instead, older files may be retained as rotated versions, with files beyond the configured retention limit subsequently removed.
Adobe documents configurable settings for the number of log-file versions retained, rotation intervals, and maximum file sizes.
These controls are especially important when DEBUG-level logging is enabled, because verbose diagnostic output can rapidly consume storage.
For production environments, rotation thresholds and retention limits should be selected according to storage capacity, troubleshooting requirements, and applicable log-retention policies.
Verification finding: All three selections match the intended question, but option A is imprecise. Log deletion depends on retention settings, and size limitation depends on the configured rotation strategy.
Official Adobe Reference: Logging — Global Logging; Loggers and Writers for Individual Services.
Batch 5 • Questions 41–50
What steps should a developer take to create a custom Oak index in AEM?
Options:
Develop a custom Sling servlet to handle the indexing process and deploy it as an OSGi bundle
Write a custom query in AEM Query Builder and let AEM automatically handle the indexing based on the query
Update the Dispatcher configuration to ensure that the new index is cached and refreshed regularly
Create a new node under /oak:index to define the index type and specify the properties to index
Answer:
DExplanation:
Comprehensive Explanation
Adobe Experience Manager uses Apache Jackrabbit Oak as its underlying content repository. Oak provides query indexes to optimize access to repository content without requiring expensive traversal operations.
A custom Oak index is defined through an index definition under the /oak:index repository hierarchy. The definition identifies the index type, indexed node types, relevant properties, and additional indexing behavior.
For Lucene indexes, the definition typically uses jcr:primaryType set to oak:QueryIndexDefinition , type set to lucene , and an appropriate asynchronous indexing configuration.
Option D correctly identifies the fundamental process of defining a custom Oak index.
Option A is incorrect because Sling servlets handle HTTP requests rather than establishing native Oak repository indexes.
Option B is incorrect because writing a Query Builder query does not automatically create the necessary custom index.
Option C is incorrect because Dispatcher manages HTTP request caching and filtering, not repository-level Oak indexing.
Cloud Service qualification: Adobe recommends maintaining custom index definitions in the application codebase and deploying them through Cloud Manager. Production developers should not manually create or modify index nodes through CRXDE Lite.
For AEM as a Cloud Service, index definitions are generally maintained under the project's _oak_index directory using versioned index names.
Official Adobe Reference: Oak Queries and Indexing; Indexing Best Practices in AEM.
A developer is naming a CQ JAR file to start an author instance on port 4502.
Which naming structure is recommended?
Options:
cq5-author-p4502-4503.jar
cq5-author-p4502.jar
cq_author_4502.jar
cq_author_4502-p4503.jar
Answer:
BExplanation:
Comprehensive Explanation
Adobe Experience Manager supports determining the initial instance run mode and listening port through the naming convention of its Quickstart JAR file.
For traditional AEM installations, the filename can include the instance type and port number.
The filename cq5-author-p4502.jar identifies an Author instance configured to start on port 4502.
The author component determines the instance role, while -p4502 identifies the configured HTTP port.
Option A is incorrect because it includes two port-related numeric values, making the naming structure unnecessarily ambiguous.
Option C does not follow Adobe's documented convention for specifying the instance type and port.
Option D also fails to follow the recommended convention and includes additional port-related information that is not required.
Adobe's standalone installation documentation explicitly provides examples using names such as cq5-publish-p4503.jar and cq5-author-p6754.jar .
The default ports for a traditional AEM installation are typically 4502 for Author and 4503 for Publish.
Version distinction: AEM as a Cloud Service development environments commonly use the newer aem-author-p4502.jar naming pattern. The cq5 prefix in this question reflects the traditional Quickstart naming convention and is appropriate among the supplied choices.
Official Adobe Reference: Custom Standalone Install — Changing the Port Number by Renaming the File; Setting Up a Local AEM Development Environment.
The Dispatcher filter can be used to allow or deny external access to specific areas of AEM.
How can access be denied for all files and then selectively allowed or denied for specific areas?
Options:
/filter {
/0001 { /glob "*" /type "deny" }
/0002 { /type "allow" /url "/libs/cq/workflow/content/console*" }
/0003 { /type "deny" /url "/libs/cq/workflow/content/console/archive*" }
}
/filter {
/0001 { /glob "*" /type "allow" }
/0002 { /type "deny" /url "/libs/cq/workflow/content/console*" }
/0003 { /type "allow" /url "/libs/cq/workflow/content/console/archive*" }
}
/filter {
/0001 { /glob "*" /type "allow" }
/0002 { /type "deny" /url "/libs/cq/workflow/content/console*" }
/0003 { /type "deny" /url "/libs/cq/workflow/content/console/archive*" }
}
Answer:
AExplanation:
Comprehensive Explanation
Adobe Experience Manager Dispatcher uses the /filter configuration to control which incoming HTTP requests can access resources on an AEM instance. Adobe recommends implementing an allowlist-based security strategy, which denies all requests initially and then explicitly permits access to approved resources.
Option A correctly follows this approach through three sequential rules.
The /0001 rule uses /glob "*" with /type "deny" to reject all incoming requests by default.
The /0002 rule selectively allows requests matching /libs/cq/workflow/content/console* .
The /0003 rule introduces a more specific restriction that denies access to /libs/cq/workflow/content/console/archive* .
Dispatcher evaluates matching filter rules in sequence, with the last matching rule determining whether a request is accepted or rejected. Consequently, the archive restriction overrides the preceding broader allowance.
Options B and C are incorrect because both begin with a global allow rule, exposing resources that have not been explicitly restricted.
Adobe recommends using specific /url , /path , and /method filters instead of deprecated broad /glob patterns for modern configurations.
Security consideration: Although A is the correct examination answer, exposing AEM workflow administrative endpoints through a public Dispatcher is generally inappropriate. Production configurations should restrict administrative URLs and follow Adobe's Dispatcher Security Checklist.
Official Adobe References: Configure AEM Dispatcher — Configure Access to Content; Dispatcher Security Checklist — Use Allowlists Instead of Blocklists.