AD0-E716 Adobe Commerce Developer Expert Free Practice Exam Questions (2025 Updated)

To minimize downtime during deployment, one of the most effective strategies is to configure static content deployment (SCD) to run during the build phase and optimize the number of threads used during the process.

Configuring SCD in the Build Phase:

Running SCD during the build phase reduces the amount of work required during the deployment phase, which helps in reducing downtime.

Increasing SCD.THREADS:

Increasing the number of threads (SCD.THREADS) speeds up the static content generation by utilizing more parallel processing, which can significantly reduce build time.

Why Option A is Correct:

Configuring SCD in the build phase and increasing SCD.THREADS are both recommended practices to minimize deployment time.

Option B’s recommendation to decrease threads would slow down SCD, and Option C does not provide an active approach to adjust thread counts for optimizing the process.

References:

Adobe Commerce Cloud documentation on SCD Configuration

The correct answer is Option A. This approach ensures that the configuration is set using the CLI with the --lock-config flag, which prevents the setting from being overridden by configuration changes in other environments.

Understanding the Configuration Requirement:

The developer needs to ensure consistent configuration across all environments without visibility into them. This calls for a method that can enforce configuration at a system level.

Setting catalog/price/scope to 1 configures pricing to be scoped at the website level, as required.

Using the CLI with --lock-config:

The command bin/magento config:set catalog/price/scope 1 --lock-config not only sets the configuration but also locks it. This lock ensures that the setting will not be inadvertently changed by system configuration settings in other environments.

By locking the configuration, the value becomes consistent across all environments and is stored in app/etc/config.php, which can be committed to version control and deployed across environments.

Why Other Options Are Incorrect:

Option B: While this option sets the configuration, it lacks the --lock-config flag. Without locking, the setting can still be overridden or altered in other environments, which does not guarantee consistency.

Option C: Modifying the config.xml for setting catalog/price/scope could be an approach, but this method is not environment-proof. It also doesn’t provide the same guarantee as using --lock-config, which explicitly prevents environment-specific changes from altering the configuration.

References:

Environment Configuration in Adobe Commerce - Details on managing environment-specific configurations and using the --lock-config flag.

Using the Magento CLI for Configuration Management - Documentation on setting and locking configuration values via CLI.

Option A is the best solution to ensure that the configuration is consistently deployed across all environments while protecting it from changes by leveraging the --lock-config option.

According to the Magento Stack Exchange answer, system.xml is a file that defines the configuration fields for the admin area. Each field can have a validate attribute that specifies a validation rule for the field value. Magento provides some built-in validation rules, such as phoneUS, which validates a US telephone number. Therefore, to ensure that the option contains a valid US telephone number, the developer needs to add phoneUS to the field in system.xml. Verified References: https://magento.stackexchange.com/questions/104570/magento-2-system-xml-validation-rules

When adding a new configuration field to the admin panel and needing to ensure it contains a valid US telephone number, you can leverage Magento’s built-in validation options within the system.xml configuration file. The correct approach is to use the tag with the desired validation type.

Built-in Validation with system.xml:

Adobe Commerce provides various validators that can be directly applied in the system.xml file for configuration fields. These validators are handled through JavaScript on the client side, ensuring real-time validation.

Using <validate>phoneUS</validate>:

The tag specifies the type of validation that should be enforced. For US phone numbers, you can simply set phoneUS.

Magento interprets this and applies a validation check to ensure the entered data conforms to the US phone number format.

Why Option A is Correct:

Option A leverages existing Magento client-side validators, which are simpler and more efficient than creating a custom backend model for a straightforward validation task.

Options B and C do not apply the correct method for a simple validation task as per Magento standards.

Example system.xml Configuration:

Out of Hours Phone

phoneUS

Enter a valid US phone number

References:

Magento DevDocs on Configuration Validation

Adobe Commerce Guide on Admin Configuration Fields

To upgrade ece-tools on Adobe Commerce Cloud, the recommended command is to use Composer to ensure that all dependencies are resolved and updated accordingly. The command composer update magento/ece-tools --with-all-dependencies will update ece-tools along with any other dependencies required.

Using Composer for Dependency Management:

Composer is the standard package manager for PHP and is used to manage dependencies, including ece-tools in Adobe Commerce Cloud. This command ensures that any required dependency updates are also applied.

Why Option B is Correct:

Option B leverages Composer's ability to handle dependencies, which is essential to avoid version conflicts.

Option A (php ./vendor/bin/ece-tools upgrade) does not exist for ece-tools. Option C is incorrect because magento-cloud ece-tools:upgrade is not a valid command for updating ece-tools.

References:

Adobe Commerce Cloud documentation on Upgrading ECE Tools

https://developer.adobe.com/commerce/php/development/components/plugins/#scenario-b-without-a-callable-around

The startEnvironmentEmulation() method resets the translation locale to the one of the emulated stores, which overrides the locale the developer has set when the order of setLocale() and startEnvironmentEmulation() is used as displayed above.

The correct way to achieve the desired result is to use the emulate() method to temporarily modify the translation locale. The following code shows how to do this:

PHP

$this->_translate->emulate('en_US');

// Render the template

$this->_translate->revert();

This code will set the translation locale to English before rendering the template, and then revert the locale back to the default value after the template has been rendered.

The startEnvironmentEmulation() method is used to emulate a different store view or website. This can be useful for testing purposes, or for developing features that need to work in different environments.

The emulate() method is used to temporarily modify the translation locale. This can be useful for rendering templates in a specific language, or for testing features that need to work in different languages.

The combination of a large number of products, categories, and stores directly affects the flat catalog indexing process. Each product needs to be indexed across all categories and stores, which exponentially increases the data size of the index tables. This can significantly slow down the frontend updates after a full product import due to the high volume of data that needs to be processed.

Impact on Flat Catalog and Indexing:

In Magento, flat catalog tables are used to optimize product data retrieval, especially in stores with a large catalog. However, with high numbers of products, categories, and stores, the flat catalog tables become massive, making them slower to update.

In this scenario, the system must create and maintain an entry for each product in each store across every category, leading to a substantial volume of data.

Why Option A is Correct:

This combination (products, categories, stores) is known to cause performance issues in indexing and data storage. It impacts the catalog indexes, which are critical for reflecting updates on the frontend.

Options B and C do not directly relate to the delay after product imports. Option B involves customer-related data, and Option C is related to price indexing, which affects a different area.

Optimization Recommendations:

Consider disabling the flat catalog and leveraging Elasticsearch for product and category search and filtering. Additionally, increasing server resources or partitioning the data could help optimize performance.

References:

Adobe Commerce documentation on Index Management

Magento DevDocs on Performance Optimization

The developer can test the new feature under the integration environment by deactivating one of the active integration environment branches, creating a new active branch from integration and installing the module, and pushing the changes. This is because Enhanced Integration Environments have a limit of four active branches at a time, and each branch has its own dedicated database and services. The developer can use the Cloud CLI for Commerce tool to manage the branches and deploy the code changes. Verified References: [Magento 2.4 DevDocs] 1

Enhanced Integration Environments in Adobe Commerce Cloud have a limit on the number of active branches. If both integration branches are currently active, one must be deactivated to create a new active branch for testing.

Creating a New Active Integration Branch:

If there are already two active branches, deactivate one to free up space for a new branch.

Then create a new branch from the integration environment, apply the changes (such as installing the new module), and push the changes.

Why Option C is Correct:

Adobe Commerce Cloud limits the number of active integration branches. Deactivating an existing branch is necessary before creating a new active branch for testing.

Option A suggests duplicating a branch without addressing the active branch limitation, while Option B disregards the need to check branch active status, which could prevent successful deployment.

References:

Adobe Commerce Cloud documentation on Branch Management

Two ways to access the PHP error logs on Adobe Commerce Cloud are to use the dedicated command from Cloud CLI for Commerce and to connect to the servers via SSH and localize the log files. The Cloud CLI for Commerce is a command-line tool that allows developers to interact with their Adobe Commerce Cloud projects and environments. The developer can use the command magento-cloud log php to view or download the PHP error logs from any environment. 

In Adobe Commerce Cloud, accessing PHP error logs can be done through the Cloud CLI or by directly connecting to the server via SSH.

Cloud CLI for Accessing Logs:

The Cloud CLI provides commands to access various logs, including PHP error logs, which can be accessed easily without directly connecting to the server.

SSH for Direct Log Access:

For more hands-on control or specific log inspection, SSH allows you to connect to the server and directly access log files located typically in the /var/log directory on Adobe Commerce Cloud environments.

Why Options A and C are Correct:

These two methods provide direct and official ways to access error logs on Adobe Commerce Cloud.

Option B is incorrect as the Project Web Interface does not have a dedicated PHP error log entry. Option D is incorrect as there is no Adobe Admin Log application.

References:

Adobe Commerce Cloud documentation on Accessing Logs

The developer can resolve this issue by creating a plugin for the Magento\Catalog\Model\Indexer\Product\Price::executeRow() method. This method is responsible for updating the product price index.

The plugin can be used to add the pricing adjustment from the database to the product price index. Once the product price index is updated, the layered navigation will display the correct price.

Here is an example of a plugin for the executeRow() method:

PHP

class MyPlugin

{

public function executeRow(

\Magento\Catalog\Model\Indexer\Product\Price $subject,

\Magento\Catalog\Model\Product $product,

array $data

) {

$adjustment = $this->getAdjustment($product);

$product->setPrice($product->getPrice() + $adjustment);

}

private function getAdjustment(Product $product)

{

$adjustment = $product->getData('adjustment');

if (!is_numeric($adjustment)) {

return 0;

}

return $adjustment;

}

}

This plugin will add the adjustment data from the product to the product price index. Once the product price index is updated, the layered navigation will display the correct price.

The developer can deal with this issue by modifying the admin path timeout value in seconds in the Fastly Configuration section > Advanced Configuration in the Admin Panel. Fastly is a cloud-based caching service that improves site performance and security for Adobe Commerce Cloud projects. Fastly has a default timeout value of 180 seconds for admin requests, which means that any request that takes longer than 180 seconds will be terminated and result in a timeout error. The developer can increase this value to allow longer processing time for admin requests without causing errors. The developer also needs to save the configuration and upload VCL to Fastly to apply the changes. Verified References: [Magento 2.4 DevDocs]

The order in which the ECE-Tools package applies patches is as follows:

All required Magento patches included in the Cloud Patches for Commerce package.

Selected optional Magento patches included in the Quality Patches Tool.

Custom patches in the /m2-hotfixes directory in alphabetical order by patch name.

The ECE-Tools package is a set of scripts and tools designed to manage and deploy Adobe Commerce Cloud projects. The Cloud Patches for Commerce package is a dependency of ECE-Tools that provides a set of required patches for Magento core issues that affect Adobe Commerce Cloud functionality. The Quality Patches Tool is an optional tool that allows developers to apply individual patches for specific Magento issues without waiting for a full product release. The /m2-hotfixes directory is a directory where developers can place their own custom patches for their Adobe Commerce Cloud projects. Verified References: [Magento 2.4 DevDocs]

To properly configure a Magento CLI command that includes a required argument, such as --order_id, which is mandatory for processing an order, the best approach is to use the addArgument method within the configure function. This method defines required arguments for the command, ensuring the user provides the necessary data.

Option D is correct for the following reasons:

Using addArgument for Required Inputs:The addArgument method is used here to declare order_id as a required argument. This is more appropriate than addOption when the parameter is essential for command execution and should not be omitted. By specifying InputArgument::REQUIRED, the command ensures that the order_id must be provided by the user.

Explanation: addArgument is ideal for required data that the command cannot function without, while addOption is typically used for optional parameters. order_id is essential to identify which order to process, making addArgument the suitable choice here.

References: According to Magento’s official developer documentation, addArgument is used for required command-line arguments, and this is standard practice for defining necessary inputs in CLI commands.

Properly Configured Command Name and Description:The setName and setDescription methods are correctly used in this option to specify the command’s name and its purpose. This helps in making the command self-descriptive, improving usability and readability for other developers or administrators using the CLI.

Options A, B, and C are incorrect because they either:

Use addOption instead of addArgument, which is less suitable for mandatory parameters (Option B).

Define the same parameter redundantly (Option C).

Use other non-standard configurations that do not align with Magento's best practices for required CLI parameters (Option A).

If the Sodium extension is installed, Argon 2ID13 will be chosen as the Magento default hashing algorithm. Otherwise, SHA256 will be used.

The Sodium extension is a PHP extension that provides cryptographic functions. Argon 2ID13 is a password hashing algorithm that is considered to be more secure than SHA256.

If the Sodium extension is installed, Magento will use Argon 2ID13 as the default hashing algorithm for customer passwords. If the Sodium extension is not installed, Magento will use SHA256 as the default hashing algorithm.

Adobe Commerce uses secure hashing algorithms for customer passwords. As of the more recent updates, Adobe Commerce defaults to using the Argon2ID13 hashing algorithm, provided that the Sodium PHP extension is available. Argon2ID is considered a secure and modern hashing algorithm designed to protect against brute-force attacks.

If the Sodium extension is not available, Adobe Commerce falls back to using SHA256, which, while secure, is not as robust as Argon2ID13.

This functionality ensures that customer data is safeguarded with the highest level of security available based on the server configuration.

Additional Resources:

Adobe Commerce Developer Guide: Hashing Algorithms

PHP Documentation: Argon2 and Sodium

The Content Security Policy (CSP) in Adobe Commerce (Magento) restricts the types of content that can be loaded on a page to protect against malicious attacks, such as cross-site scripting (XSS). When an iframe is added, and a JavaScript library is loaded from an external source, these resources must be whitelisted explicitly using the csp_whitelist.xml file.

In this specific case:

The frame-src directive controls the sources from which iframes can be embedded. Since the developer is embedding an iframe from an external domain, they need to whitelist this domain for frame-src.

The script-src directive controls the sources from which JavaScript files can be loaded. The external JavaScript library must be whitelisted under script-src to allow it to execute.

Therefore, the correct policy IDs to whitelist are:

frame-src: to allow the embedding of content from an external domain in an iframe.

script-src: to allow the loading and execution of JavaScript files from the external domain.

Here’s how to update the csp_whitelist.xml file with the correct directives:

Replace your-external-domain.com with the actual domain of the external iframe and JavaScript source.

Additional Resources:

Adobe Commerce Developer Guide: Content Security Policy (CSP)

CSP Policies and Directives: Explanation of all supported CSP directives and how to configure them.

To prevent the media_gallery attribute from being exported as part of the custom entity's data, the developer should add this attribute to the $_disabledAttrs class property array. This effectively excludes the attribute from the export process, ensuring that it does not appear in the exported file and thus will not be modified or re-imported inadvertently.

Option C is correct for the following reasons:

Preventing Export with $_disabledAttrs:Adding media_gallery to the $_disabledAttrs array tells the system to skip this attribute during export. This prevents the attribute from being included in the export file, thus removing the risk of it being altered by external software that handles the file. Since the attribute will not be present in the exported data, it will remain unchanged in the database when re-importing.

Explanation: The $_disabledAttrs property is specifically designed to exclude certain attributes from the export process. By using this property, you ensure that attributes not intended for editing or visibility in exports are safely omitted, maintaining data integrity.

References: The Adobe Commerce documentation on import/export processes outlines how $_disabledAttrs can be used to filter out sensitive or unnecessary attributes from export files.

Alternative Options and Their Limitations:

Option A: Using $_transformAttrs with a serializer is useful for encoding or decoding attribute data during export/import, but it does not prevent the attribute from being included in the export. This would only help if the media_gallery data needed transformation, not exclusion.

Option B: $_strippedAttrs is applicable for filtering attributes from the imported file, not the exported file. It would not stop the attribute from being included in the export and hence does not align with the need to prevent modifications during export.

By configuring $_disabledAttrs, the developer effectively ensures the media_gallery attribute remains unmodified by preventing it from being included in export files altogether.

To allow the is_delayed EAV attribute to be used in the .phtml cart page, the developer needs to create a new file called etc/catalog_attributes.xmi. This file will contain the definition of the is_delayed attribute.

The following code shows how to create the etc/catalog_attributes.xmi file:

XML

Is Delayed

This attribute indicates whether the product is delayed.

10

false

Once the etc/catalog_attributes.xmi file has been created, the is_delayed attribute will be available in the .phtml cart page. The attribute can be accessed using the getIsDelayed() method of the Product class.

PHP

$product = $block->getProduct();

$isDelayed = $product->getIsDelayed();

The isDelayed variable will contain the value of the is_delayed attribute. If the value of the attribute is 1, then the product is delayed. If the value of the attribute is 0, then the product is not delayed.

The developer should create an extension attribute on the Magento\Sales\Api\Data\OrderInterface interface and an after plugin on the Magento\Sales\Api\OrderRepositoryInterface::get() and Magento\Sales\Api\OrderRepositoryInterface::getList() methods.

The extension attribute will store the custom data. The after plugin will be used to add the custom data to the order object when it is fetched from the API.

Here is the code for the extension attribute and after plugin:

PHP

namespace MyVendor\MyModule\Api\Data;

interface OrderExtensionInterface extends \Magento\Sales\Api\Data\OrderInterface

{

/**

* Get custom data.

*

* @return string|null

*/

public function getCustomData();

/**

* Set custom data.

*

* @param string $customData

* @return $this

*/

public function setCustomData($customData);

}

namespace MyVendor\MyModule\Model;

class OrderRepository extends \Magento\Sales\Api\OrderRepositoryInterface

{

/**

* After get order.

*

* @param \Magento\Sales\Api\OrderRepositoryInterface $subject

* @param \Magento\Sales\Api\Data\OrderInterface $order

* @return \Magento\Sales\Api\Data\OrderInterface

*/

public function afterGetOrder($subject, $order)

{

if ($order instanceof OrderExtensionInterface) {

$order->setCustomData('This is custom data');

}

return $order;

}

/**

* After get list.

*

* @param \Magento\Sales\Api\OrderRepositoryInterface $subject

* @param \Magento\Sales\Api\Data\OrderInterface[] $orders

* @return \Magento\Sales\Api\Data\OrderInterface[]

*/

public function afterGetList($subject, $orders)

{

foreach ($orders as $order) {

if ($order instanceof OrderExtensionInterface) {

$order->setCustomData('This is custom data');

}

}

return $orders;

}

}

Once the extension attribute and after plugin are created, the custom data will be added to orders fetched from the API.

In Adobe Commerce Cloud, outgoing emails are disabled by default on Integration environments to prevent test or development emails from being sent to real customers.

Email Configuration on Integration Environments:

Emails are disabled on Integration environments by default to prevent accidental communications during development. This behavior is a standard setting and cannot be overridden in Integration.

Why Option B is Correct:

This is a standard practice in Adobe Commerce Cloud, as email functionality is disabled to prevent disruptions. Options A and C are not applicable since Integration environments do not support outgoing emails regardless of additional settings.

References:

Adobe Commerce Cloud documentation on Email Configuration