Development-Lifecycle-and-Deployment-Architect Salesforce Certified Development Lifecycle and Deployment Architect (WI25) Questions and Answers

The development model that the architect should recommend to be used by the consolidated development team is the package development model. This model allows teams to build release artifacts that can be tested and released independently from artifacts for other projects, using unlocked packages or second-generation managed packages. This model can help improve the modularity, reusability, and maintainability of the code and configuration, as well as enable source-driven development and continuous integration and delivery. The org development model is not a good choice for the consolidated development team, as it is based on working directly in an org and using change sets or metadata API tools to deploy changes. This model can lead to conflicts, dependencies, and governance issues, especially when working on multiple projects or with multiple teams. The change set development model is also not a good choice for the consolidated development team, as it is based on using change sets to deploy changes between connected orgs. This model can be slow, error-prone, and limited, as it does not support all metadata types, dependencies, or automation. The package development model does not allow packages to be created and deployed using declarative (point-and-click) development tools, without writing code. This is a wrong statement, as the package development model supports both declarative and programmatic development tools, and requires writing code to create and install packages using the Salesforce CLI or APIs. See Package Development Model for more details.

C is the correct answer, as creating a custom metadata type and including this in your deployment to production is the best way to manage this deployment. A custom metadata type is a metadata component that can store important configuration data, such as custom settings, and can be deployed along with other components, such as Apex classes. A is incorrect, as scripting the deployment of all functionality via the Force.com Migration Tool is not a good way to manage this deployment, as it does not address the issue of deploying the custom settings that hold the configuration data. B is incorrect, as manually deploying and populating custom settings in production using a change set is not a good way to manage this deployment, as it can introduce errors and inconsistencies, as well as require additional steps and permissions. D is incorrect, as manually deploying and populating the custom settings in production prior to the Apex class deployment is not a good way to manage this deployment, as it can create dependency and timing issues, as well as require additional steps and permissions. You can learn more about this topic in the [Custom Metadata Types] module on Trailhead.

The best deployment tool for UC to use to manage their deployment process in an automated fashion is the Force.com Migration Tool, as it is a command-line tool that uses the Metadata API to deploy components from one org to another, and can be integrated with version control systems and continuous integration servers. Option A is not a good choice, as Workbench is a web-based tool that does not support automation or scripting. Option C is not a good choice, as Change Sets are a point-and-click tool that require manual steps to create and deploy. Option D is not a good choice, as Force.com IDE is a desktop tool that does not support automation or scripting.

 The two actions that can effectively contribute to the quality and agility of the team are: Define and follow code standards, and use static code analysis tool in the pipeline before manual code review. Code standards can help ensure consistency, readability, and maintainability of the code, as well as reduce errors and bugs. A static code analysis tool can help automate the code review process and identify any issues or violations of the code standards before the manual review. Choosing the most senior developer to help the technical lead or skipping the code review are not effective actions, as they can lead to more errors and delays.

A source control tool provides the ability for distributed teams to work in isolation, as they can create branches and merge their changes later. It also provides the ability to backup code/configuration changes, as they can be stored in a remote repository and retrieved if needed.

 The success criteria for data migration and the manual and automated data validation approaches are two key areas of UC’s data migration test plan that should be included. The success criteria define the expected outcomes and quality standards for the data migration process. The data validation approaches ensure that the data is accurate, complete, and consistent after the migration.

The recommendation to satisfy the customer requirements is to use a Continuous Integration and Continuous Deployment tool and build the pipeline to deploy to sandboxes and production. A Continuous Integration and Continuous Deployment tool can automate the process of building, testing, and deploying the changes to different environments, as well as provide feedback and visibility into the deployment status and results. This can help to streamline and accelerate the deployment process, as well as to ensure consistency and quality across the environments. Using SFDX and documenting the deployment commands with steps to be executed for each environment is not a good recommendation, as it still requires manual intervention and execution, which can be error-prone and time-consuming. Using ANT script and building a custom application to run the script and use change sets to deploy supported metadata is not a good recommendation, as it involves using multiple tools and methods, which can increase the complexity and risk of the deployment process. Using an AppExchange solution that packages the deployment components and you can run the deployment wizard to track deployment result is not a good recommendation, as it may not support all the metadata types and features that need to be deployed, and it may not integrate well with the SFDX tools and methodologies that UC is using.

Presenting the feature requests at a Center of Excellence meeting and creating the backlog or priority list in a project management tool are two options that can help to get feedback and prioritize the requests. A Center of Excellence meeting can provide a forum for discussing the business value, feasibility, and impact of the requests with the stakeholders. A project management tool can help to track, organize, and prioritize the requests based on the agreed criteria.

Program team and executive sponsors are two user groups that an architect should recommend to join the COE. A program team is a group of people who are responsible for managing and delivering the Salesforce projects and initiatives. They can provide the COE with the technical expertise, best practices, and project management skills. An executive sponsor is a senior leader who supports and advocates for the Salesforce program. They can provide the COE with the strategic direction, business alignment, and funding support.

 A and C are the correct answers, as they are the project situations that favor an agile methodology. An agile methodology is a flexible and iterative approach that can accommodate changing requirements, deliver value quickly, and enable frequent feedback and collaboration. A is correct, as a digitization project to update an existing customer-facing process and enable quick adjustments is a situation that requires an agile methodology, as it involves transforming a legacy system, adapting to customer needs, and delivering incremental improvements. C is correct, as an environment with a heavy investment in DevOps capabilities for rapid testing and deployment is a situation that requires an agile methodology, as it enables continuous integration and delivery, as well as quality assurance and automation. B is incorrect, as a project to be executed by a third party, with a fixed and formal scope, budget, and timeline is a situation that favors a waterfall methodology, as it involves clear and stable requirements, contractual obligations, and sequential phases. D is incorrect, as a project with well-defined requirements and complex interactions between front- and back-end systems is a situation that favors a waterfall methodology, as it involves detailed planning, design, and testing, as well as minimal changes and dependencies. You can learn more about this topic in the Agile Basics module on Trailhead.

 Creating a Center of Excellence with a charter document is a recommended practice for managing multiple projects and aligning them with the business goals and roadmap. A Center of Excellence is a cross-functional team that provides guidance, support, and governance for the Salesforce ecosystem. A charter document defines the vision, mission, roles, and responsibilities of the Center of Excellence.

 REST API SObject Tree Request and REST API Composite Request are two ways to insert multiple related records in one call or transaction. REST API SObject Tree Request allows you to create nested records that share a root record. REST API Composite Request allows you to execute a series of REST API requests in a single call. Bulk API 2.0 and Streaming API are not suitable for inserting multiple related records in one call or transaction. Bulk API 2.0 is used for loading large batches of data asynchronously, and Streaming API is used for receiving notifications of data changes in real time.

Load testing is the type of testing that will help UC measure the page response time. Load testing simulates the expected number of concurrent users and measures how the system performs under normal load conditions. Unit testing, system integration testing, and stress testing are not designed to measure the page response time.

To improve the performance of the development teams, the following ways can be suggested: Define and follow code standards, and implement a sprint review process. Code standards can help ensure consistency, readability, and maintainability of the code, as well as reduce errors and bugs. A sprint review process can help evaluate the work done in each sprint, demonstrate the functionality, and gather feedback from the stakeholders and users.

The recommended mechanism for releasing the application that can be installed in the trading partners’ Salesforce environments is a managed package. A managed package is a collection of application components that can be distributed and installed in other orgs. Managed packages allow you to control the visibility and upgradability of the components, as well as provide namespace isolation and license management. Change sets are not suitable for releasing applications to other orgs, as they can only be used for orgs that are affiliated with the same production org. Unmanaged packages are not ideal for releasing applications that need to be updated frequently, as they do not allow you to push upgrades or control the components after installation. Zip file deployable by SFDX or ANT is not a user-friendly way of releasing applications, as it requires the users to have technical knowledge and tools to install the components.

The three benefits of using a partner development org over an individual development org in this scenario are:

Partner development org has a greater number of licenses available for the team. This means that the developers can test their app with different user profiles and permissions, and also invite beta testers to provide feedback2.

Partner development org offers higher API limit. This means that the developers can use more API calls to integrate their app with external systems or services, and also leverage the Salesforce APIs to automate their development and deployment processes2.

Partner development org offers more storage. This means that the developers can store more data and files in their org, and also use more features and components that require storage, such as Big Objects, Platform Events, or Lightning Web Components2.

The other options are not benefits of using a partner development org over an individual development org in this scenario, because:

Only partner development org supports managed beta testing. This is not true, as both partner development org and individual development org can create and distribute managed beta packages3.

Partner development org never expires. This is also not true, as partner development orgs have a 12-month expiration period, which can be extended by request

This is the correct answer because Salesforce prohibits stress testing against production because it is a shared environment that hosts multiple customers and tenants. Stress testing against production may affect the performance and availability of the Salesforce service for other customers and violate the terms of service. Stress testing should be done in a sandbox or a developer edition org that is isolated from production.

Deploying unsupported components manually before/after deployment is the best way to address the issue of Metadata API not supporting all the components yet. Metadata API is a powerful tool for deploying changes between orgs, but it does not cover all the metadata types that are available in Salesforce. Some examples of unsupported components are email templates, dashboards, reports, and custom settings. These components need to be deployed manually by using other tools or methods, such as change sets, data loader, or manual configuration.

 Scratch orgs are the best development environments for the package development model, as they allow developers to start a new project, start a new feature branch, or start automated testing in a disposable and configurable org. Scratch orgs also track all the changes automatically and can be easily integrated with version control systems. Scratch orgs can coexist with other models, such as the org development model, but this is not the main reason to start using them. Dev sandboxes are not suitable for the package development model, as they are not within the code deployment path and they do not support source-driven development.

Kanban can help clarify whether value is being delivered to the business by using metrics, like lead time and throughput, which increase transparency. Lead time measures how long it takes to complete a work item from the time it is requested, and throughput measures how many work items are completed in a given time period. These metrics can help the business stakeholders see the progress and performance of the development teams, and align their expectations with the reality. Kanban does not respond to unplanned work and changes by dropping everything and jumping on the new request, as this would disrupt the flow and quality of work. Kanban does not make use of the Salesforce Agile Accelerator, as this is a tool for managing agile projects. Kanban does limit work in progress, but this is not the main reason why it can help clarify whether value is being delivered to the business.

The org development model is a traditional approach that uses sandboxes as the primary development environments. It relies on tools such as change sets, the Ant Migration Tool, or the Metadata API to deploy changes between orgs. One of the benefits of this model is that it allows automated deployment, meaning that the deployment process can be scripted and executed without manual intervention. This can save time and reduce errors. Another benefit of this model is that it allows automated sandbox provisioning, meaning that the creation and configuration of sandboxes can be done programmatically using the Sandbox API or the Salesforce CLI. This can help maintain consistency and alignment across different environments. Automated defect fixing and automated change tracking are not characteristics of the org development model, but rather of the package development model, which uses source code as the source of truth and supports source tracking and automated testing.

The best option is to send a package.xml file with associated metadata in a .zip file to the Release Management team, as this will allow them to use the Metadata API to deploy the components to the production org. Option A is not feasible, as change sets cannot be downloaded from sandboxes. Option B is not sufficient, as the readMetadata call only retrieves the metadata information, not the actual components. Option C is not reliable, as the audit trail may not capture all the changes made in the sandbox.

Implementing the change in the sandbox, validating, and releasing to production and considering that the integration with the ERP system may not function as expected are two considerations when addressing the requirement. The change should be performed in the sandbox first, as it is a best practice to test any changes in a non-production environment before deploying them to production. The change may also affect the integration with the ERP system, as it may require updating the mappings, validations, or transformations between the two systems.

Develop, Build Release, and Test are three steps that apply to any Salesforce development project, regardless of the size, complexity, or methodology. Develop is the step where the developers create the code and configuration components that meet the requirements and specifications. Build Release is the step where the components are packaged and deployed to different environments for testing and validation. Test is the step where the components are verified and validated against the requirements and specifications, as well as the quality and performance standards. Continuous Integration and Change Sets are not steps, but tools or techniques that can be used to facilitate the development project. Continuous Integration is a technique that involves merging the code from different developers frequently and automatically, to ensure consistency and avoid conflicts. Change Sets are a tool that allows the developers to move the components from one org to another org.

The best practice is to always fix the bug in the developer environment where the project work was done, and follow the normal deployment and testing process. This ensures that the code is consistent, traceable, and validated across all environments. Fixing the bug in UAT is not ideal, as it can introduce new issues, create conflicts with other changes, and bypass the version control system. Spinning up a new sandbox for a hot fix is not necessary, as it can add complexity and overhead to the deployment process. Treating the issue as a change request and putting it in the backlog is not advisable, as it can delay the resolution and affect the user experience.

The best option is to refactor the approach to the feature in an upgraded sandbox, as this will allow the developer to test the compatibility and functionality of the code with the new platform release. Option A is risky, as Salesforce may not fix the issue before the production upgrade. Option B is not feasible, as changing the API version of the code will not change the platform version of the sandbox. Option C is not recommended, as delaying the upgrade will only postpone the problem and may cause more issues later.

 To reduce defects, the architect should recommend increasing the code coverage to 95% and adding more details to the acceptance criteria. Increasing the code coverage can help ensure that the code is thoroughly tested and meets the quality standards. Adding more details to the acceptance criteria can help clarify the requirements and expectations for the functionality. Using the test script to define the test classes or having the test analyst create the test classes are not good practices, as they can introduce errors and inconsistencies in the testing process.

 A is the correct answer, as generating a destructivechanges.xml file and deploying the package via the Force.com Migration Tool is the best way to manage the deletions of metadata components across sandbox environments and production with minimal impact on other work streams. A destructivechanges.xml file is a special file that specifies the components to be deleted from an org, and can be deployed using the Force.com Migration Tool, which is a command-line tool that uses the Metadata API to retrieve and deploy metadata components. This method can help to automate and streamline the deletion process, as well as ensure consistency and accuracy across the environments. B is incorrect, as performing deletes manually in a sandbox and then deploying a change set to production is not a good way to manage the deletions, as it can introduce errors and inconsistencies, as well as require additional steps and permissions. C is incorrect, as assigning business analysts to perform the deletes and splitting up the work between them is not a good way to manage the deletions, as it can create confusion and complexity, as well as lack of coordination and integration. D is incorrect, as deleting the components in production and then refreshing all sandboxes to receive the changes is not a good way to manage the deletions, as it can disrupt the production environment and the ongoing development and testing activities in the sandboxes. You can learn more about this topic in the Deploy Changes with the Force.com Migration Tool unit on Trailhead.

 Two options that should be considered when making production changes in a highly regulated and audited environment are: all changes including hotfixes should be reviewed against security principles, and any production change should have explicit stakeholder approval. These options can help ensure that the changes are compliant with the regulations and have the necessary authorization and documentation. No manual steps should be carried out is not a valid option, as some changes may require manual steps, such as data migration or post-deployment verification. After deployment, the development team should test and verify functionality in production is also not a valid option, as testing and verification should be done in a lower environment before deploying to production, and the responsibility of testing and verifying functionality in production should be assigned to a different team than the development team. See Application Lifecycle and Deployment for more details.

Using continuous integration with automation testing is a development practice that will help to reduce the amount of bugs, as it allows the code to be built and tested frequently and automatically. Encouraging the development team to do peer code review is a development practice that will help to reduce the amount of bugs, as it allows the code to be checked and improved by other developers. Incorporating test-driven development into the project structure is a development practice that will help to reduce the amount of bugs, as it requires the developers to write tests before writing code and ensure that the code meets the test criteria. Enabling the development team to be self-organizing is not a development practice that will help to reduce the amount of bugs, as it does not directly affect the quality of the code. Enabling a short and timely feedback loop with customers is not a development practice that will help to reduce the amount of bugs, as it does not directly affect the quality of the code.

The only condition that would make continuous integration unsuitable for UC is if their Salesforce instance has only standard functionality, as this would mean that there is no need for code deployment or version control. Option A is not a valid reason, as test scripts can be generated and executed as part of the continuous integration process. Option B is not a valid reason, as a full sandbox is not a requirement for continuous integration, and other types of sandboxes can be used instead. Option D is not a valid reason, as there are free or low-cost software tools available for continuous integration, such as Jenkins, Git, and Ant

 C and D are the correct answers, as Load Test and Performance Test are the test types that should be suggested to ensure that a large inbound call center does not experience platform slowdowns under high call volume for the Lead object. A load test is a test that measures the performance and behavior of the system under a specific load, such as a large number of concurrent users or requests. A performance test is a test that measures the speed, responsiveness, and stability of the system under various conditions, such as different configurations or environments. These tests can help to identify and prevent any potential issues or bottlenecks that could affect the user experience or the system functionality. A is incorrect, as Unit Test is not a test type that should be suggested for this scenario, as it is a test that verifies the functionality and logic of a single unit of code, such as a method or a class, but not the performance or behavior of the system as a whole. B is incorrect, as Stress Test is not a test type that should be suggested for this scenario, as it is a test that measures the performance and behavior of the system under extreme or abnormal conditions, such as exceeding the capacity or resources of the system, but not the performance or behavior of the system under normal or expected conditions. You can learn more about these tests in the Testing Strategies module on Trailhead.

: Storing the records in sandboxes and production is not a good practice, as it can lead to data inconsistencies and conflicts. Storing the records in a version control system is a better option, as it allows tracking changes and deploying them to different environments. Using a third-party product to manage these records is also a valid option, as it can provide features such as data backup, restore, and migration.

 The maximum size of deployed .zip file is 39MB for Metadata API. You can deploy up to 10,000 files, but retrieve more than 10,000 files using Metadata API.

 A and C are the correct answers, as they are the methods that should be used to mitigate the risk of code being overwritten by a large development team in a single developer pro sandbox. A is correct, as providing each developer their own sandbox developer org and implementing a code repository and continuous integration to merge code into the developer pro sandbox can help to isolate the changes, avoid conflicts, and ensure consistency and quality. C is correct, as using a single sandbox and strictly coordinating development across shared components, and implementing a code repository to allow developers to merge code into a common repository can help to manage the changes, prevent overwriting, and ensure version control and integration. B is incorrect, as replacing the developer pro sandbox with a partial copy sandbox is not a method that can mitigate the risk of code being overwritten, as it does not address the issue of multiple developers working on the same components, but only provides a larger data set for testing. D is incorrect, as providing each developer their own sandbox developer org, and implementing managed packages to deploy to the merge is not a method that can mitigate the risk of code being overwritten, as it does not allow for easy updates and modifications, but only creates locked and versioned components. You can learn more about this topic in the Application Lifecycle and Deployment module on Trailhead.

 An application with many systems and inter-dependencies between components is a project situation that favors a waterfall methodology, as it requires a high level of planning and design upfront to ensure the integration and compatibility of the components. An application with regulatory compliance requirements to be validated by outside agencies is also a project situation that favors a waterfall methodology, as it requires a clear and detailed documentation of the requirements and specifications, as well as a formal and rigorous testing and validation process. An application in post-production, with incremental changes made by a small team is a project situation that favors an agile methodology, as it allows for faster and more frequent delivery of changes, as well as more flexibility and collaboration. An in-house application with a fixed team size, but an open timeline and flexible requirements is also a project situation that favors an agile methodology, as it allows for more creativity and experimentation, as well as more feedback and adaptation.

These are the correct answers because they are related to the data quality and integrity of the migrated data. Case association, case ownership, and data transformation are all important aspects of data migration that should be tested. Case assignment rules and escalation rules are not directly related to data migration, but rather to the business logic and workflow of the application. Page layout assignment is also not related to data migration, but rather to the user interface and security of the application.

An unmanaged package is a suitable option for deploying an application from a contractor’s own Salesforce to UC’s Salesforce environments. An unmanaged package allows the contractor to share the application code with UC, while giving UC full control and ownership of the code. An unmanaged package also does not require a namespace prefix or a security review.

B and D are the correct answers, as partner developer edition orgs and developer edition orgs are the appropriate environments for creating a managed package. A managed package is a collection of application components that are locked and versioned, and can be installed and upgraded in multiple orgs. A is incorrect, as developer pro sandbox orgs are not suitable for creating a managed package, as they are copies of a production org that are used for development and testing purposes. C is incorrect, as production orgs with LMA are not suitable for creating a managed package, as they are used for managing the licenses and subscribers of a managed package. You can learn more about this topic in the Package Development Model module on Trailhead.

When migrating a flow with change sets, the following statements should be considered: When a change set with a multiple versioned flow is uploaded, it includes only the active version of the flow. When a change set with a multiple versioned flow is uploaded, and no active version is available, it includes the most recent inactive version of the flow. These statements are based on the Salesforce documentation on how change sets handle flows with multiple versions. The other statements are incorrect, as they do not reflect the actual behavior of change sets.

The package development model relies on source tracking to automatically track the metadata changes in the package project. However, not all metadata components are supported by source tracking, and some changes may need to be tracked manually. For example, changes to profiles, permission sets, custom metadata types, and custom settings are not supported by source tracking. You can find the list of unsupported components here1. No manual tracking is required for the changes that are supported by source tracking, nor for the changes made via the Setup UI, as they are automatically captured by the package development model.

 Fixing the issue in hotfix, testing, and deploying to production is the best option when UC has PI issues and has to be fixed immediately. A hotfix sandbox is a type of sandbox that is used for emergency fixes in production. It is a copy of the production org and has a shorter refresh interval than other sandboxes. A hotfix sandbox allows the team to quickly fix and test the issue without affecting the ongoing development and release cycles.

The architect should recommend the use of an automated testing tool daily in all Developer Orgs, and when branches are merged. This strategy allows the team to catch and fix any errors or bugs early in the development cycle, and to ensure that the code is stable and consistent before deployment. Running automated tests only when branches are merged is not sufficient, as it may delay the detection and resolution of issues. Running automated tests only in Full or Partial Copy sandboxes is not advisable, as it may not cover all the scenarios and environments.

QUESTIONNO: 172

Universal Containers (UC) is a large enterprise with a complex system landscape. UC is

currently rolling out new infrastructure and strategies around Salesforce DevOps. Some of the

key feature’s UC is looking to support is rollback of metadata after a deployment, and the

backup and restore of data to help recover from deployment issues, system bugs, or outages in

their downstream systems.

Regulations in the industry mean that UC must be able to provide strategies to recover and

rollback from issues. The regulator has discovered UC is not currently providing these, and must

do so as soon as possible to remain compliant.

What should an architect advise?

A. Salesforce backs up all data and will restore it for customers on request.

B. Evaluate third-party and AppExchange products.

C. Advise stakeholders that rollback is not possible for Salesforce.

D. Custom build a feature rollback and data restore tool for Salesforce

Answer: B

The architect should advise UC to evaluate third-party and AppExchange products that can provide the features they are looking for, such as rollback of metadata and backup and restore of data. Salesforce does not offer these features natively, and building a custom solution can be costly and time-consuming. There are several products available in the market that can help UC meet their regulatory requirements and recover from issues. For example, Gearset is a DevOps tool that can perform metadata rollback and data backup and restore, among other features

 The sfdx force:source:retrieve command is used to retrieve the metadata from an org to a local project directory. However, before running this command, the developer needs to create a project using the sfdx force:project:create command, and then navigate to the project directory using the cd command. If the developer hasn’t done these steps, they will get the error message: “This command is required to run from within an SFDX project”. The -n option is not required for the sfdx force:project:create command, as it will prompt the developer to enter a project name interactively. The developer can create the project within VSCode and run the command in a separate terminal, as long as they are in the same project directory.

Utilizing a dedicated developer pro sandbox to address critical bugs and release to production is the recommended release management strategy, as it allows the development team to work on the new project without being interrupted by the bug fixes, and also ensures that the bug fixes are deployed to production as soon as possible. Including fixes for critical bugs in the ongoing development sandboxes is not recommended, as it may delay the release of the bug fixes and also introduce conflicts with the new code. Keeping teams separate until the end of the project and creating a full copy sandbox to merge their work then is not recommended, as it may create a lot of merge conflicts and integration issues. Addressing critical bugs in the development sandboxes and pushing those changes to production separately is not recommended, as it may create inconsistencies between the development and production environments.

A and D are the correct answers, as they are the locking behaviors that will occur during a deployment. A is correct, as the production org will be locked and administrators cannot modify metadata during this time, to prevent any conflicts or inconsistencies in the deployment. D is correct, as the production org will be locked and users will still be able to read/write data to the org, to minimize the impact on the business operations and user experience. B is incorrect, as the sandbox org will not be locked and administrators can still modify metadata, as the sandbox org is not the target of the deployment. C is incorrect, as the production org will not be locked and users can only read data during this time, as this would disrupt the business operations and user experience. You can learn more about the locking behaviors in the [Deploy Changes with Change Sets] unit on Trailhead.

Three areas that should be tested as part of data migration are: data transformation against source system, contact association with correct account, and account and lead ownership. These areas can help ensure that the data is migrated correctly and accurately, and that the relationships and ownership are preserved. Lead assignment is not an area that should be tested as part of data migration, as it is a business process that is triggered after the data is migrated. Page layout assignments is also not an area that should be tested as part of data migration, as it is a configuration setting that is independent of the data. See Data Migration for more details.

An agile team is one that improves and evolves its processes and frequently delivers value to the end users. This is the main characteristic of an agile team, as opposed to a traditional team that follows a fixed plan and delivers on predefined dates. Agile teams use various frameworks, such as Scrum, Kanban, and Extreme Programming, but these are not essential to be agile. Agile teams also have shorter iterations, such as biweekly sprints, but these are not the only way to ensure on-time delivery.

Active Process Builders are configuration items that should be covered by executable tests, as they can have complex logic and actions that affect the behavior and performance of the application. Validation Rules, Workflow Rules, and Case Assignment Rules are also configuration items, but they are simpler and less likely to cause errors or conflicts. Therefore, they can be verified by manual testing or declarative tools.

A and B are the correct answers, as installing an Aloha certified app and upgrading to an Enterprise Edition org are the best solutions to enable advanced quoting in the current Professional Edition org. An Aloha certified app is an app that does not count against the org limits, such as objects and tabs, and can provide additional functionality and features. Upgrading to an Enterprise Edition org can increase the org limits, as well as provide access to more customization and automation options. C is incorrect, as creating and installing an unmanaged package is not a good solution, as it will consume the org limits and may not provide the desired functionality. D is incorrect, as buying more user licenses will not increase the org limits, but only the number of users who can access the org. You can learn more about this topic in the Salesforce Editions and Limits module on Trailhead.

Using static code analysis to enforce coding standards is the best way to improve consistency among the development teams working on different projects. Static code analysis is a tool that can automatically scan the code and detect any violations of the predefined coding rules and best practices. It can also provide feedback and suggestions to the developers on how to improve their code quality and readability. Creating a Center of Excellence for release management, requiring pull requests to be reviewed by two developers before merging, or executing regression testing before code can be committed are also good practices, but they are not as effective or efficient as static code analysis for ensuring coding consistency.

User centered design is a process that involves understanding the user needs, preferences, and behaviors before building the solution. This way, the solution can be tailored to the user’s goals and expectations, and increase the likelihood of adoption and satisfaction. Using Lightning Web Components, stopping development, or sending communication emails are not effective ways to overcome the problem of unused features.

 Creating a release calendar, training and aligning all the teams is the best way to avoid conflicts and ensure smooth releases between major, minor, and Salesforce seasonal releases. A release calendar can help the teams plan ahead, coordinate their efforts, and avoid overlapping or conflicting changes. Training and aligning the teams can help them understand the release processes, the best practices, and the expectations for each release type. Gating all release decisions at the center of excellence, sharing the test plans, or creating a spreadsheet of metadata changes are not sufficient or scalable solutions for this problem.

A change to a multi-org strategy can be justified by two reasons: launching a new line of business with independent processes and acquiring a company that has its own Salesforce org and operates in a different business with its own set of regulatory requirements. These reasons indicate that the single-org strategy is no longer feasible or optimal, as it would require too much customization, complexity, and compliance. Using Chatter for collaboration among different business units is not a reason to change to a multi-org strategy, as Chatter can work across multiple orgs. Following a unification enterprise architecture operating model is also not a reason to change to a multi-org strategy, as this model implies having orgs with the same processes implemented for each business unit, which is more suitable for a single-org strategy.

 Using a Source Control system alongside a multi-sandbox development strategy has several advantages, such as performing code reviews before promoting to a pre-production sandbox, keeping a history of changes made by each developer, and creating a branching strategy that tracks each feature or change separately. Automatically deploying changes from sandbox to production is not an advantage of Source Control, but rather a function of a Continuous Integration tool. Acting as a backup in case of catastrophic data loss is not an advantage of Source Control, but rather a benefit of having a sandbox strategy.

The best option for UC is to refresh Stage now, and do not refresh UAT. This way, Stage will be on the preview instance and UAT will not. This will allow UC to test their application on both the current and the next Salesforce version, and ensure that they can release on the current version without any issues. Option B is incorrect because it is not necessary to check the Sandbox Preview Guide or refresh and redeploy to UAT. Option C is incorrect because it is too late to work with support to get on the preview instance after the cutoff dates. Option D is incorrect because it will result in both Stage and UAT being on the same version, which will not allow UC to test their application on the next Salesforce version.

 DOM changes introduced by a release can cause automated browser tests to need updating, as they can affect the way the browser interacts with the web page elements and the selectors used to identify them. New standard fields, metadata schema changes, and new Apex methods are not likely to affect automated browser tests, as they are mostly related to the backend functionality and data model of Salesforce. See [Automated Browser Testing] for more details.

The best environment for developing a new feature in an org with unlocked packages is a scratch org with the package code that will be changed and its dependencies. A scratch org is a source-driven and disposable deployment of Salesforce code and metadata that is fully configurable and can be created quickly. A scratch org can also install unlocked packages and their dependencies, which can help ensure compatibility and functionality of the new feature. A Developer Pro sandbox is not a good option, as it is not source-driven and can have outdated or conflicting data and metadata.

Tracking effort estimates, actuals, and remaining work can help the developer improve their estimation skills and accuracy, which can benefit the project planning and delivery.

The sandbox types that the architect should recommend for batch data testing are Partial Copy sandbox and Full sandbox. These sandbox types allow the testing of large data sets that are similar to the production data. Developer Pro sandbox and Developer sandbox have limited storage and may not be able to accommodate the data needed for the batch data testing.

A suitable branching policy to recommend for multiple development teams that work on separate streams of work, with different timelines, is trunk-based development. This policy allows each team to work on their own feature branches, and merge them to the main branch (trunk) frequently, using pull requests and code reviews. This can help avoid merge conflicts, ensure code quality, and enable continuous integration and delivery. Leaf-based development is not a valid branching policy, as it is a term used to describe the nodes in a tree data structure. GitHub flow is a specific implementation of trunk-based development, but it is not a branching policy by itself. Scratch-org-based development is not a branching policy, but a development model that uses scratch orgs as ephemeral environments. See Trunk-Based Development for more details.

To deploy custom metadata types to production using Metadata API, you need to include the CustomMetadata and CustomField data types. CustomMetadata represents the custom metadata type definition, and CustomField represents the custom metadata type fields. CustomMetadataType and CustomObject are not valid data types for custom metadata types

 The following issues could be affecting their deployment times:

The number and complexity of Apex tests will have a large impact on the deployment time, as the tests will take longer to run and consume more resources.

Some components such as profiles, custom junction objects, and fields take longer to process than others, as they have more dependencies and validations to check.

Users are working in the org during deployment can affect users and the deployment, as they can lock records or metadata components that are being deployed, causing errors or delays.

 B and D are the decisions that should be made by an Architecture Review Board (ARB), as they involve choosing the best methodology and authentication mechanism for the project, which have significant impacts on the project scope, quality, and security. A is not a decision that should be made by an ARB, as it is a low-level design decision that can be made by the developers or technical leads. C is not a decision that should be made by an ARB, as it is a testing decision that can be made by the testers or quality assurance leads.

QUESTIONNO: 87

What is the process used to initiate a connection for change sets?

A. Modify the source org to allow an outbound connection to the target org

B. Modify the target org to accept an outbound connection from the source org

C. Modify the target org to accept an inbound connection from the source org

D. Modify the source org to allow an inbound connection to the target org

Answer: A

A is the correct answer, as the process to initiate a connection for change sets is to modify the source org to allow an outbound connection to the target org. B and C are incorrect, as the target org does not need to accept any connection from the source org, but only to deploy the inbound change sets that are sent from the source org. D is incorrect, as the source org does not need to allow any inbound connection to the target org, but only to create and upload the outbound change sets to the target org. You can learn more about this process in the Change Sets Basics module on Trailhead.