I85PREP
⌘ K
AEM Sites Developer Expert study materials
AEM Sites Developer Expert study resources

AEM Sites Developer Expert practice questions

One question at a time. Build your AEM Sites Developer Expert understanding.

First 50 of 200 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.

Continue in the practice tool above to load more questions, 50 at a time.

Question 1AEM Sites architecture and component development

In AEM, which file in a component's folder defines the component's dialog for authoring?

  1. cq:dialog
  2. cq:htmlTag
  3. _cq_dialog Correct answer.
  4. cq:editConfig

Explanation

Dialogs are stored as a node named _cq_dialog (with sling:resourceType cq/gui/components/authoring/dialog) directly under the component node. The underscore prefix marks it as an authoring-time resource that is not rendered on the page. cq:editConfig controls editing behavior, not the dialog fields.

Question 2AEM Sites architecture and component development

Which Sling script resolution order applies when a resource of type myproject/components/text is rendered?

  1. Scripts in /apps are ignored in favor of /libs
  2. The script with the shortest filename is selected first
  3. The most specific resource type path is searched first, then super types Correct answer.
  4. Only scripts named exactly after the resource type are considered

Explanation

Sling builds a list of resource types starting with the exact type and walking up the sling:resourceSuperType chain, searching each for a matching script. The first match wins. This lets projects override or extend library components via super types.

Question 3AEM Sites architecture and component development

What is the primary purpose of the HTL (Sightly) data-sly-use block element?

  1. To declare client-side JavaScript libraries for the page
  2. To include a static HTML fragment from the file system
  3. To define a new editable dialog field
  4. To instantiate a Java or JavaScript Use-API object and expose it to the template Correct answer.

Explanation

data-sly-use binds a server-side logic object, resolved through the Use-API, to a variable usable in the template. It separates business logic from markup. It does not load client libraries or dialogs.

Question 4AEM Sites architecture and component development

A developer needs to add a new field to an existing dialog inherited through sling:resourceSuperType. What is the recommended AEM approach?

  1. Edit the dialog in /libs directly
  2. Delete the super type and rebuild the component
  3. Copy the entire dialog into the project component
  4. Use a resource merger with sling:resourceSuperType and override only the needed node Correct answer.

Explanation

Sling resource merging lets a component inherit a dialog from its super type while overriding or adding only specific nodes. This avoids duplicating the whole dialog and keeps library upgrades safe. Editing /libs is discouraged because changes can be overwritten.

Question 5AEM Sites architecture and component development

Which annotation exposes a Java class as an HTL model through the Use-API?

  1. @SlingServlet
  2. @Model Correct answer.
  3. @Reference
  4. @Component

Explanation

The @Model annotation from the Sling Models framework registers a class as an adaptable model, which HTL can consume via data-sly-use. @Component is OSGi, @Reference injects services, and @SlingServlet registers servlets.

Question 6AEM Sites architecture and component development

How does a Sling Model declare which resource types it can adapt from?

  1. With a properties file in /etc
  2. With resourceType and optionally resourceSuperType in @Model Correct answer.
  3. With the adaptables attribute only
  4. With the @Inject annotation alone

Explanation

The @Model annotation accepts resourceType (and resourceSuperType) to register the model for those types. adaptables declares the adaptable classes such as Resource or SlingHttpServletRequest. Registration by resource type lets HTL resolve the model automatically.

Question 7AEM Sites architecture and component development

Which statement best describes the role of the sling:resourceSuperType property?

  1. It points to a parent component whose scripts and dialog can be inherited Correct answer.
  2. It sets the client library category for the component
  3. It specifies the servlet path used to render the component
  4. It defines the JCR primary node type of the component

Explanation

sling:resourceSuperType establishes an inheritance link so Sling can fall back to the parent's scripts and merge its dialog. It enables reuse and extension of existing components. It does not set node types, clientlibs, or servlet paths.

Question 8AEM Sites architecture and component development

A component must render different markup for touch and classic authoring UI without duplicating business logic. Which mechanism is designed for this?

  1. A single dialog with hidden fields per editor
  2. Two separate components with different resource types
  3. Editor-specific HTL scripts selected by the editor's resource type Correct answer.
  4. Client-side JavaScript that rewrites the DOM

Explanation

AEM supports editor-specific rendering by resolving scripts based on the editor's resource type, such as cq.authoring.editor.hook. This keeps one component while allowing tailored markup for each authoring UI.

Question 9AEM Sites architecture and component development

What does the data-sly-resource block element do in HTL?

  1. It loads a Java class as a model
  2. It renders another resource, optionally with resource type and selectors Correct answer.
  3. It declares a reusable template fragment
  4. It includes the current component's dialog definition

Explanation

data-sly-resource delegates rendering to another resource, allowing developers to embed components and pass options such as resourceType, selectors, and request attributes. It is commonly used for container-style components.

Question 10AEM Sites architecture and component development

Which HTL statement correctly iterates a list and exposes the loop status?

  1. data-sly-use.item="${list}"
  2. data-sly-include.item="${list}"
  3. data-sly-repeat.item="${list}"
  4. data-sly-list.item="${list}" with itemList exposed Correct answer.

Explanation

data-sly-list iterates a collection and provides a status variable (by default itemList) with index, count, first, last, and other properties. data-sly-repeat repeats an element but does not provide the same list status object.

Question 11AEM Sites architecture and component development

How should a component expose authorable text so that it is safely escaped in HTL output?

  1. Output ${properties.text} without context
  2. Concatenate strings in a Java model and print raw
  3. Use ${properties.text @ context='unsafe'}
  4. Use ${properties.text @ context='html'} for rich text Correct answer.

Explanation

HTL applies contextual escaping automatically; specifying context='html' allows intended HTML from rich text while still protecting against scripts. Choosing the correct context balances formatting with security.

Question 12AEM Sites architecture and component development

Which node under a component enables in-place editing and defines listeners?

  1. cq:actions
  2. cq:template
  3. sling:resourceType
  4. cq:editConfig Correct answer.

Explanation

cq:editConfig holds editing configuration such as cq:actions, cq:listeners, and in-place editing settings. It governs how the component behaves in the authoring UI.

Question 13AEM Sites architecture and component development

A developer wants a component to appear in the component browser only for certain page templates. Which mechanism controls this?

  1. The jcr:title of the component
  2. The sling:resourceSuperType property
  3. The allowedComponents setting in the template's policy Correct answer.
  4. The component group name only

Explanation

Editable templates use policies that can restrict which components are allowed in a container or on a template. This governs availability in the component browser per template context.

Question 14AEM Sites architecture and component development

What is the function of a proxy component in AEM?

  1. It caches rendered HTML for performance
  2. It duplicates the library component's scripts into the project
  3. It points to a library component via sling:resourceSuperType to allow safe customization Correct answer.
  4. It proxies requests to an external server

Explanation

A proxy component has no scripts of its own but sets sling:resourceSuperType to a library component. Projects customize by adding scripts or dialogs to the proxy, keeping the library intact.

Question 15AEM Sites architecture and component development

Which client library technique ensures a component's CSS and JS are included only once per page even if the component appears multiple times?

  1. Embedding the category in every HTL script
  2. Relying on the dispatcher to deduplicate
  3. Using the page component to include the category once Correct answer.
  4. Adding the clientlib category to each component instance

Explanation

Client library categories are aggregated at the page level, so including the category once in the page template ensures assets load once regardless of instance count. Per-instance inclusion risks duplicate references.

Question 16AEM Sites architecture and component development

Which HTTP method and selector combination is commonly used to render a component's JSON representation for a Sling Model exporter?

  1. DELETE with the .json extension
  2. GET with the .model.json extension Correct answer.
  3. POST with the .html extension
  4. PUT with the .xml extension

Explanation

Sling Model Exporter exposes models as JSON through the model selector and json extension, requested with GET. This enables headless consumption of component data. Other methods and extensions do not map to the exporter.

Question 17AEM Sites architecture and component development

A component's HTL references ${model.title}, but the page renders nothing. The model is registered with resourceType matching the component. What is the most likely cause?

  1. The component is missing a cq:editConfig node
  2. The model class lacks a public getter for title Correct answer.
  3. The page template has no clientlib category
  4. The model uses @Model without adaptables

Explanation

HTL accesses model properties through public getter methods (getTitle for title). A missing getter means the expression resolves to nothing. Registration and resource type are already correct per the scenario.

Question 18AEM Sites architecture and component development

Which statement about HTL expressions and Java method calls is accurate?

  1. HTL requires JSP tag libraries for logic
  2. HTL executes inline Java code blocks
  3. HTL can access getters and permitted methods without parentheses Correct answer.
  4. HTL can call arbitrary Java methods with parameters

Explanation

HTL is intentionally limited: it accesses properties via getters and a restricted set of allowed methods, without arbitrary parameterized calls. Logic belongs in Use-API classes. This restriction keeps templates safe and maintainable.

Question 19AEM Sites architecture and component development

What does the cq:isContainer property on a component indicate?

  1. The component renders a parsys or layout container for child components Correct answer.
  2. The component inherits from a proxy
  3. The component is read-only in the editor
  4. The component is hidden from the component browser

Explanation

cq:isContainer marks a component as a container that can host child components, typically used with layout containers and parsys. It signals drop-target behavior in the editor.

Question 20AEM Sites architecture and component development

A developer needs to read a request parameter inside an HTL template. Which approach follows AEM best practice?

  1. Embed a JSP include to read the parameter
  2. Use a scriptlet block in the HTL file
  3. Call request.getParameter directly in HTL
  4. Expose the value through a model or Use-API object Correct answer.

Explanation

HTL should not contain business logic; parameters are read in a model or Use-API class and exposed as properties. This keeps templates declarative and testable. Direct request access or scriptlets violates the separation.

Question 21AEM Sites architecture and component development

Which combination correctly describes how a page component and its template relate in editable templates?

  1. The page component stores content; the template defines rendering
  2. Both are identical and interchangeable
  3. The template is only used for static templates
  4. The template stores content structure; the page component defines rendering Correct answer.

Explanation

With editable templates, the template holds the initial content structure and policies, while the page component provides the rendering scripts and resource type. Content authored by users lives in page instances.

Question 22AEM Sites architecture and component development

What is the effect of the sling:resourceType property on a content node?

  1. It determines which component renders the node Correct answer.
  2. It defines the node's workflow status
  3. It specifies the node's version history
  4. It sets the node's access control list

Explanation

sling:resourceType tells Sling which component to use to render the resource, driving script resolution. It has no bearing on permissions, workflow, or versioning.

Question 23AEM Sites architecture and component development

Which HTL attribute correctly includes a reusable template fragment defined with data-sly-template?

  1. data-sly-call Correct answer.
  2. data-sly-test
  3. data-sly-resource
  4. data-sly-use

Explanation

A fragment declared with data-sly-template is invoked with data-sly-call, optionally passing parameters. This promotes reuse of markup within and across templates.

Question 24AEM Sites architecture and component development

A component must render a list of child pages with their titles and links. Which approach is most appropriate?

  1. Use client-side JavaScript to fetch page titles
  2. Use a Sling Model that queries child pages and expose them to HTL Correct answer.
  3. Hard-code links in the HTL template
  4. Add each page manually through the dialog

Explanation

Querying child pages belongs in server-side logic such as a Sling Model, which exposes results to HTL for rendering. This keeps templates clean and supports dynamic content. Hard-coding or manual entry does not scale.

Question 25AEM Sites architecture and component development

Which statement about the HTL data-sly-test attribute is correct?

  1. It removes the element and its children when the expression is false Correct answer.
  2. It throws an exception when the expression is false
  3. It hides the element with CSS when false
  4. It repeats the element for each item in a list

Explanation

data-sly-test conditionally renders the host element and its children; when the expression evaluates false, the whole block is omitted from output. It is the standard conditional construct in HTL.

Question 26AEM Sites architecture and component development

In an AEM project, what is the primary purpose of the ui.apps package?

  1. It stores the compiled OSGi bundles for the project
  2. It provides the JCR repository configuration for the instance
  3. It contains the /apps content such as components, templates, and client libraries Correct answer.
  4. It holds immutable content packages that can never be modified

Explanation

The ui.apps package deploys code-like content under /apps, including component definitions, editable template definitions, and client libraries. OSGi bundles are built by the core bundle module, not ui.apps.

Question 27AEM Sites architecture and component development

Which file extension identifies an HTL script inside an AEM component?

  1. .js
  2. .jsp
  3. .html Correct answer.
  4. .xml

Explanation

HTL scripts use the .html extension and are interpreted by the HTL/Sightly engine. JSP scripts use .jsp and are handled by a different script engine.

Question 28AEM Sites architecture and component development

What does an HTL block element such as <div data-sly-unwrap> accomplish when rendered?

  1. It defers rendering of the element to the client side
  2. It renders the element but hides it with a CSS display rule
  3. It removes the element itself from the output while keeping its content Correct answer.
  4. It escapes the element's content as plain text

Explanation

data-sly-unwrap strips the host element from the generated markup while still processing its children, which is useful when a wrapper tag is not wanted. The content is still rendered normally.

Question 29AEM Sites architecture and component development

Which AEM construct lets an author change a component's dialog field values on a page without a code deployment?

  1. The component's HTL script
  2. The component's dialog definition Correct answer.
  3. The component's sling:resourceType
  4. The component's client library

Explanation

The dialog defines the authorable fields whose values are stored as properties on the component's content node. Authors edit those values through the dialog, and the HTL reads them at render time.

Question 30AEM Sites architecture and component development

A developer wants a Sling Model to be available only for a specific component resource type and to be injectable into HTL via ${model}. Which annotation attribute achieves the resource type binding?

  1. @Model(adaptables = Resource.class, defaultInjectionStrategy = DefaultInjectionStrategy.OPTIONAL)
  2. @Model(adaptables = Resource.class, adapters = Component.class)
  3. @Model(adaptables = SlingHttpServletRequest.class, cache = true)
  4. @Model(adaptables = Resource.class, resourceType = "myproject/components/text") Correct answer.

Explanation

The resourceType attribute on @Model registers the model for that specific resource type so it can be resolved through the model factory. The adaptables attribute alone registers the model for any adaptable of that type.

Question 31AEM Sites architecture and component development

Which HTL expression safely outputs an author-provided string inside an HTML attribute value context?

  1. ${properties.title @ context='html'}
  2. ${properties.title @ context='text'}
  3. ${properties.title @ context='uri'}
  4. ${properties.title @ context='attribute'} Correct answer.

Explanation

HTL applies context-aware escaping based on where the expression appears. For an HTML attribute value, the attribute context escapes characters that could break out of the attribute.

Question 32AEM Sites architecture and component development

A page component uses editable templates. Where are the structural policies and allowed components for a given template stored?

  1. In the page's cq:Page node under jcr:content
  2. In the component's cq:dialog definition
  3. In the template's /conf structure alongside the template definition Correct answer.
  4. In the /etc/designs node for the site

Explanation

Editable templates and their associated policies live under /conf, separate from page content. Policies constrain what authors can place and configure within the template's structure.

Question 33AEM Sites architecture and component development

Which statement correctly describes how a component inherits a dialog from its supertype?

  1. The child must copy the parent dialog file to reuse its fields
  2. The child cannot inherit dialog fields at all
  3. The dialog is merged automatically so the child shows both inherited and own fields Correct answer.
  4. The child inherits only the parent's HTL, not its dialog

Explanation

When a component declares a sling:resourceSuperType, its dialog is merged with the supertype's dialog, so inherited fields appear alongside the component's own fields. This enables reuse without duplicating dialog definitions.

Question 34AEM Sites architecture and component development

A developer needs to make a component's dialog field required so authors cannot leave it empty. Which Granite UI construct enforces this?

  1. Setting the field's name property to a non-empty value
  2. Adding the field to the component's HTL template
  3. Adding a validation property such as required to the field's Granite UI definition Correct answer.
  4. Setting cq:isContainer to true on the component

Explanation

Granite UI fields support validation properties, such as required, that the authoring UI enforces client-side before saving. The name property only determines the JCR property the value is stored under.

Question 35AEM Sites architecture and component development

Which approach correctly passes a parameter into an HTL template fragment defined with data-sly-template?

  1. Use data-sly-use to inject the parameter into the template
  2. Use data-sly-resource with a selector equal to the parameter name
  3. Use data-sly-call with an object argument matching the template's declared parameter name Correct answer.
  4. Use data-sly-repeat to iterate the parameter into the template

Explanation

A template fragment declares named parameters, and data-sly-call supplies an object whose keys match those parameter names. This is the supported mechanism for parameterizing reusable fragments.

Question 36AEM Sites architecture and component development

A developer must expose a component's data as JSON for a Sling Model Exporter. Which combination is required?

  1. Add a data-sly-resource call in the component's HTL
  2. Set sling:resourceType to the exporter class name
  3. Annotate the model with @Model and set cache to true
  4. Annotate the model with @Exporter and provide a Jackson exporter configuration Correct answer.

Explanation

Sling Model Exporter requires the model to be annotated with @Exporter, naming an exporter such as the Jackson exporter. This registers a servlet that serializes the model when the appropriate selector and extension are requested.

Question 37AEM Sites architecture and component development

A component must render a value that may be null and should show a fallback only when it is present. Which HTL construct expresses this cleanly?

  1. data-sly-unwrap on the value
  2. data-sly-include on the value
  3. data-sly-test with the value, wrapping the fallback markup Correct answer.
  4. data-sly-list on the value

Explanation

data-sly-test evaluates a condition and renders its host element and children only when the expression is truthy. Using it to guard the fallback markup avoids rendering when the value is null.

Question 38AEM Sites architecture and component development

A developer wants a component's client library to load only on pages where that component is actually used. Which approach best achieves this?

  1. Declare the client library as a dependency of the component's own client library category and include that category from the component Correct answer.
  2. Add the client library script tag directly in the component's HTL
  3. Embed the client library in the page's global clientlib
  4. Put all component CSS in a single site-wide client library

Explanation

Scoping a client library to the component's category and including it from the component means it is requested only when the component renders. Embedding into a global library loads assets on every page.

Question 39AEM Sites architecture and component development

A page renders through the editable template's structure, but a developer adds a component directly to the template structure node. What is the effect on pages that use the template?

  1. The component is copied into each page's content on creation
  2. The component is hidden from authors and never rendered
  3. The component appears on all pages using the template and is not authorable per page Correct answer.
  4. The component replaces the page's parsys entirely

Explanation

Components placed in the template structure are rendered on every page that uses that template and are locked from per-page authoring. Authors add their own components in the page's editable layout container instead.

Question 40AEM Sites architecture and component development

A Sling Model uses @ChildResource to inject a child node, but the injection is null at runtime. Which cause best explains this?

  1. The child node's name does not match the name given in @ChildResource and no default is set Correct answer.
  2. The model's adaptable is SlingHttpServletRequest and the child is not a request attribute
  3. The component's HTL does not declare data-sly-use
  4. The model is registered for a different adaptable than Resource

Explanation

@ChildResource resolves a child node by name relative to the adaptable resource; if the name does not match and no fallback is provided, the injection yields null. The injection strategy may also need to be optional to avoid failing the model.

Question 41Templates, policies, and editable templates

Which node type must a template's root node use for the template to be recognized as an editable template?

  1. cq:Page
  2. nt:unstructured
  3. cq:Template Correct answer.
  4. sling:Folder

Explanation

Editable templates store their configuration under a node of type cq:Template, which is what distinguishes them from content pages and makes them available to the template editor. A cq:Page is a content page, not a template definition.

Question 42Templates, policies, and editable templates

In an editable template, which node holds the template's structural content such as the initial layout and components?

  1. jcr:content/root
  2. jcr:content/structure Correct answer.
  3. jcr:content/policies
  4. jcr:content/initial

Explanation

The structure node stores the template's structural content, including the responsive grid and any components that appear on every page. Policies and initial content live in separate sibling nodes.

Question 43Templates, policies, and editable templates

Which node in an editable template stores the mapping of components to policies that control their allowed behavior?

  1. jcr:content/structure
  2. jcr:content/initial
  3. jcr:content/policies Correct answer.
  4. jcr:content/settings

Explanation

The policies node maps component resource types to policy nodes, determining which design properties apply to each component in the template. Structure and initial content are stored in their own dedicated nodes.

Question 44Templates, policies, and editable templates

What is the primary purpose of the 'initial' node in an editable template?

  1. To define the template's editable layout grid
  2. To hold the policy mappings for components
  3. To store default content that is copied to new pages Correct answer.
  4. To list which components are locked for authors

Explanation

The initial node holds default content (such as placeholder text or preconfigured components) that is copied into a page when it is created from the template. It is distinct from structure and policies.

Question 45Templates, policies, and editable templates

Which statement best describes the relationship between an editable template and a static template?

  1. Static templates require a policy node, while editable templates do not.
  2. Editable templates are defined in code, while static templates are authored in the template editor.
  3. Editable templates are authored in the template editor and stored in the repository, while static templates are defined in code under the app. Correct answer.
  4. Both are authored in the template editor and stored in /conf.

Explanation

Editable templates are content-based: authors create and edit them in the template editor, and they are stored in the repository. Static templates are developer-defined in the codebase under the application folder.

Question 46Templates, policies, and editable templates

Where are editable templates typically stored in the repository?

  1. /content/dam/templates
  2. /conf/<project>/settings/wcm/templates Correct answer.
  3. /etc/designs
  4. /apps/<project>/templates

Explanation

Editable templates are stored under the project's configuration branch, conventionally /conf/<project>/settings/wcm/templates. This makes them part of the editable, content-based configuration.

Question 47Templates, policies, and editable templates

Which tool is used to create and modify editable templates?

  1. The page editor
  2. The Sites console
  3. The workflow console
  4. The template editor Correct answer.

Explanation

The template editor is the dedicated UI for authoring editable templates, including their structure, policies, and initial content. The Sites and page consoles are for managing and editing content pages.

Question 48Templates, policies, and editable templates

What is the purpose of the 'locked' setting on a component inside an editable template's structure?

  1. It prevents authors from editing or deleting that component on pages created from the template. Correct answer.
  2. It prevents the component from being rendered on the page.
  3. It restricts the component to administrators only.
  4. It hides the component from the component browser.

Explanation

Locking a component in the template structure prevents authors from modifying or removing it on pages based on that template, enforcing a fixed layout. It does not affect rendering or visibility in the component browser.

Question 49Templates, policies, and editable templates

A developer needs a component's allowed components to be restricted on pages created from a template. Where is this best configured?

  1. In the page's jcr:content node
  2. In the component's cq:dialog
  3. In the template's structure node
  4. In a policy assigned to the layout container in the template Correct answer.

Explanation

The allowed components for a layout container are governed by a policy, which is mapped in the template's policies node and applied to the container. This centralizes the restriction at the template level.

Question 50Templates, policies, and editable templates

Which node type is used for a policy node that configures a component's design properties in an editable template?

  1. sling:OsgiConfig
  2. cq:Page
  3. cq:Component
  4. nt:unstructured Correct answer.

Explanation

Policy nodes are typically stored as nt:unstructured nodes under the policies branch, holding properties that map to the component's design dialog. They are not pages, components, or OSGi configurations.