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

A product owner is responsible for defining the scope and prioritizing the backlog of the project. A product owner can help the COE manage the scope creep between the different projects by aligning the business goals and ensuring the value delivery. A scrum master, a release manager, and a change manager are not directly involved in scope management.

Waterfall development methodology has some positive aspects, such as:

Complex processes that will need to be built are thoroughly understood and documented before coding begins, which can reduce the risk of ambiguity and rework.

Milestones, timelines and estimates tend to be more accurate and predictable due to the upfront due diligence, which can help with project management and stakeholder expectations.

Deploying metadata to production orgs using package development model is the best option for the multi-org deployment strategy, as it allows you to create modular and reusable packages that can be easily installed and updated across different orgs. Deploying metadata to production orgs using managed packages is not suitable for this scenario, as managed packages are typically used by ISVs to distribute their applications to customers, and they have some limitations and restrictions that may not fit the requirements of UC. Deploying metadata to production orgs using unmanaged packages is also not a good option, as unmanaged packages are mainly used for one-time distribution of components, and they do not support upgrades or dependencies. Deploying metadata to production orgs using change sets is not feasible for this scenario, as change sets can only be used to deploy metadata between connected orgs in the same Salesforce instance, and UC has separate orgs for each region. See [Package Development Model] for more details.

Pairing with the administrator and reviewing each change as it happens is the best way to handle the situation of discovering a Sev0 defect in production. This way, the architect can ensure that the changes are done correctly and quickly, without compromising the quality or security of the application. The architect can also provide guidance and feedback to the administrator, as well as monitor the impact and outcome of the changes. Denying the suggestion, explaining that only developers are certified to make changes, or calling the security team are not advisable actions, as they can delay the resolution of the defect, increase the damage, or create unnecessary conflict.

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

Two advantages of automated test data loads over manual data loads are that automated loads can be done with no human oversight and that automated loads are reliable in their results. Automated loads can be scheduled and executed without human intervention, which saves time and effort. Automated loads can also ensure that the data is consistent and accurate, which reduces errors and risks. Automated loads do not necessarily increase costs, as they can also save money in the long run by improving efficiency and quality. Automated loads can also be scripted by CICD tools, which is one of the benefits of using them.

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 track Salesforce metadata throughout the development lifecycle across sandboxes and production, the architect should recommend using an AppExchange or third-party tool that is specialized in Salesforce deployment. These tools can provide features such as version control, dependency analysis, automated testing, and rollback capabilities. Using an Excel sheet to track deployment steps and document the SFDX commands is not a reliable or scalable solution, as it is prone to human errors and does not provide any automation or validation. Using ChangeSet to track deployed customizations is also not a good option, as ChangeSet is limited in the types of metadata it can deploy and does not support versioning or dependency management. Using Salesforce SFDX commands to deploy to different sandboxes is a possible solution, but it requires a high level of technical expertise and does not provide a graphical interface or reporting capabilities.

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.

These are the correct answers because they are essential components of a governance framework that helps to manage the changes and enhancements to the Salesforce application. Requirements management is the process of capturing, analyzing, prioritizing, and tracking the business needs and requests. Change control log is the tool that records and tracks the status of all change requests and approvals. Documentation repository is the central place that stores and organizes all the project artifacts and deliverables. Automated testing and continuous integration are not necessary components of a governance framework, but rather best practices for ensuring the quality and reliability of the code and configuration.

 Identifying the relevant data and verifying the data integrity can help ensure the quality and accuracy of the migrated data. Using a full sandbox and performing test runs with real data can help validate the migration process and identify any issues or risks.

 Generating a code review checklist to ensure consistency between reviews and different reviewers and conducting a review that combines human efforts and automatic checks by the tool to detect all flaws are two recommended practices to follow when conducting secure code reviews, as they can help improve the quality and security of the code and reduce the risk of vulnerabilities or errors. Focusing on the aggregated reviews to save time and effort, to remove the need to continuously monitor each meaningful change is not a good practice, as it can miss important details or changes that can affect the code functionality or security. Using the code review software as the tool to flag which developer has committed the errors, so the developer can improve is not a constructive way of conducting code reviews, as it can create a blame culture and discourage collaboration and learning. See  Secure Coding Guidelines  for more details.

Integrating an agile issue tracker with software testing and continuous integration tools can provide the following benefits:

Developers can see automated test statuses that commit on a specific user story, which can help them identify and fix any errors or failures quickly.

Developers can use the committed code’s build status directly on the user story record, which can help them track the progress and quality of their work.

The Scrum value that is compromised by this bad practice is courage, because the teams should be transparent about progress and speak up when they need help. Courage is one of the five core values of Scrum, and it means that the team members have the courage to do the right thing and work on tough problems. By not updating the status of their work in progress, the team is hiding potential issues and risks, and not being honest with themselves and others.

 A and C are the advantages of using an Agile Project Management tool, as they provide visibility into the project progress and status, and consolidate the project artifacts in a common repository. B is not an advantage of using an Agile Project Management tool, as it depends on the communication and collaboration skills of the team members and stakeholders. D is not an advantage of using an Agile Project Management tool, as it is more related to the governance framework and methodology of the project

 The change set performance may depend on the included components, especially if they are complex or have many dependencies. The change set may take more time than usual if it includes changes to permission sets and profiles, as these components require additional validation and processing. The change set may not take more time if it includes field type changes, new custom objects and fields, or other simple components.

The best option is to ensure the sandbox will be on the release preview, which means it will be upgraded to the new platform release before the production environment. This will allow the team to test the deployment in a realistic scenario and catch any potential issues. Option A is not ideal, as the staging and production support sandboxes will not be on the same platform version as the production environment. Option C is also not ideal, as the production support sandbox will not be on the same platform version as the production environment. Option D is risky, as the staging sandbox refresh may not complete in time for the go-live.

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 options to enforce code quality in UC’s continuous integration process are to introduce manual code review before deployment to the testing sandbox and to introduce static code analysis before deployment to the testing sandbox. Manual code review can help identify and fix any errors, bugs, or best practices violations in the code. Static code analysis can help check the code quality, complexity, and security using automated tools and standards. Introducing manual code review before deployment to the production org may be too late, as the code may have already caused defects or issues in the testing sandbox. Increasing the size of the testing team assigned to the project may not improve the code quality, as the testing team may not have the skills or authority to review or modify the code. Testing data creation is outside the scope of code quality.

This is the correct answer because developers should work on feature branches that are derived from the develop branch, which represents the latest stable version of the code. The feature branches should then be merged back into the develop branch after they are completed and tested. This way, the develop branch always contains the most updated code that is ready for release.

 Automated browser testing and static code quality analysis are two quality assurance techniques that can help minimize defects in software projects, and that an architect should recommend for Universal Containers to incorporate into its overall CI/CD pipeline. Automated browser testing is a technique that involves using tools or frameworks to simulate user interactions with the web application across different browsers and devices, and to verify the functionality and performance of the application. Static code quality analysis is a technique that involves using tools or frameworks to scan the code and detect any violations of the predefined coding rules and best practices, such as syntax errors, security issues, code smells, etc. Business verification testing and stress testing are also quality assurance techniques, but they are not as suitable or relevant for the CI/CD pipeline, as they are more focused on validating the business requirements and the system capacity.

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.

Change sets provide an easy way to deploy related components, as they allow the user to select the components from a list and add them to the change set. They also provide a simple and declarative method for deployment, as they do not require any coding or scripting. Change sets do not provide the ability to deploy a very large number of components easily, as they have a limit of 10,000 components per change set. They also do not provide the ability to track changes to components, as they do not have any version control or history features.

Implementing a Hub-and-Spoke multi-org strategy by consolidating customer data in a single org, which will be the master of customer data, and using integration strategies to let the LOBs orgs read and write from it is one of the options an architect can recommend to accomplish the customer 360-degree view. This way, the architect can ensure that there is a single source of truth for the customer data, and that the data is consistent and synchronized across the different orgs. Implementing a Single Package multi-org strategy by developing and deploying to all orgs a managed package which reads and consolidates customer 360-degree view from the different orgs is another option an architect can recommend, as it allows the architect to create a reusable and scalable solution that can provide a unified view of the customer data from multiple sources. Implementing a Complete Graph multi-org strategy or migrating from multi-org to single-org strategy are not feasible or optimal options, as they can introduce complexity, cost, or risk to the architecture.

 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.

 In the change set model, the source of truth is a combination of the metadata already in the environment and the content of your change set, as you stated correctly. However, a change set cannot be retrieved from the developer’s workbench as a package, nor can it be pushed into the version control system. Change sets are only available within the Salesforce UI, and they are not compatible with version control systems. In the package development model, the source of truth is the metadata in the package project, which makes it easy to integrate to a version control system, as you stated correctly. Additionally, in the package development model, the best practice is to consider the dependencies and build them into the package so it can be deployed in any other target orgs. This ensures that the package is self-contained and does not rely on external components that may not exist in the target org.

The best practice is to fix the issues in the development sandbox, migrate them to the testing sandbox, and deploy to production after testing. This ensures that the development and testing environments are in sync and that the changes are properly tested before going to production. Fixing the issues in the testing environment and deploying them to production may introduce errors or conflicts, as the development environment may not have the same changes. Fixing the issues in the test environment and migrating them to the development sandbox may also cause errors or conflicts, as the development environment may have other changes that are not ready for testing.

 Agile development methodology allows for frequent and incremental releases of functional code, which enables stakeholders to provide feedback and validate the requirements. Agile development methodology also embraces changes in the project requirements as the business needs evolve, and adapts to them accordingly.

 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.

 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.

 In the post refresh plan, modifying external ids to a known valid set of values for UAT is the best way to resolve the issue of objects that have external ids from production no longer pointing to valid external ids in the UAT environment. This way, the data integrity and consistency across the integrated systems can be maintained. Letting UAT point to production integrations and rolling back each transaction after it finishes is not a good practice, as it can cause data loss or corruption in production. Deleting all the data and using an automated testing tool to create new data across all the systems in UAT is not feasible, as it can take a lot of time and resources. Masking the external id so nobody can see the production value is not a solution, as it does not address the underlying problem of invalid references.

 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.

Going to a single-org strategy can provide several benefits, such as lower administration overhead costs, improved Chatter collaboration across different business units, and easier to get a 360-view of the customer. Consolidating the business processes and unifying the data model among all lines of business are not benefits of a single-org strategy, but rather challenges that need to be addressed during the org merge process.

The best way to migrate from a managed package to an unlocked package is to split the components into two packages: one for the objects and fields, and one for the classes, Visualforce, and other components. This way, the data and integrations with the objects and fields of the managed package are preserved, and the classes and Visualforce can be modified and deployed using CI/CD processes with the unlocked package. Exporting and restoring the data from the managed package is not a feasible solution, as it would require a lot of effort and risk data loss or corruption. Installing the unlocked package with the same namespace as the managed package is not possible, as namespaces are unique and cannot be reused. Staying with the managed package is not a good option, as it does not allow for better integration with CI/CD processes.

The Executive Steering Committee is the management team that is empowered to approve additional budget requirements for a project, as they are responsible for providing strategic direction, oversight, and governance for the project. The Security Review Committee is responsible for ensuring that the project meets the security standards and policies of the organization. The Project Management Committee is responsible for managing the day-to-day activities and deliverables of the project. The Change Control Board is responsible for reviewing and approving any changes to the project scope, schedule, or resources.

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 Metadata API can be used to migrate configuration changes between two organizations or export current customization in the organization as an xml file. The Metadata API allows developers to retrieve, deploy, create, update, or delete the metadata components that define the structure and behavior of the Salesforce org. The Metadata API cannot perform CRUD operations to manage records in the organization or migrate data changes between two organizations using a csv file. These operations require the use of other APIs, such as the REST API or the Bulk API.

Maintaining separate developer branches for minor and major releases, maintaining a single repository for applications with individual branches for projects, and maintaining a single-entry point for production from the master branch are three best practices that UC should consider for version control. These practices help to:

Isolate and manage different types of changes in separate branches, such as bug fixes, enhancements, or new features 1 .

Organize and track the code and configuration for each application and project in a logical and consistent way 2 .

Ensure that the master branch reflects the current state of production and that only tested and approved changes are deployed to production

 D is the correct answer, as utilizing automated source control, test, and build systems to test and deploy to production can help to maintain quality and reduce the risk of bugs being introduced to production. Automated systems can ensure that the code is consistent, version-controlled, tested, and validated before deploying to production. A is incorrect, as requiring developers to deploy completed code and unit tests directly to production can introduce errors and conflicts, as well as bypass the testing and validation stages. B is incorrect, as deploying all functionality together can create complexity and dependency issues, as well as delay the release of completed features. C is incorrect, as using a spreadsheet to track approved changes that should be released with change sets can be prone to human errors and inconsistencies, as well as lack of automation and integration. You can learn more about this topic in the  Continuous Integration and Continuous Delivery  module on Trailhead.

The two sandbox types that would be appropriate to use as the hotfix environment are Developer sandbox and Developer Pro sandbox. These sandbox types are suitable for testing and deploying quick fixes, as they are easy to create and refresh, and have a minimal data and metadata footprint. A Partial Copy sandbox or a Full sandbox would be too large and complex for a hotfix environment, and would take longer to create and refresh.

 The daily release process is the most suitable for creating a new report to support an urgent client request, as it can deliver the functionality in a timely manner. Creating the report in a full sandbox and then deploying it to production can ensure the quality and security of the report.

The advantages of the package development model are improving team development and collaboration, facilitating automated testing and continuous integration, and significantly reducing the need for manually tracking changes. The package development model allows the developers to work on modular and reusable components that can be easily tested and deployed. The package development model does not eliminate the need of using change sets, as they can still be used for deploying non-packaged components or metadata. The package development model does not provide its own source control, but rather relies on external source control systems such as Git.

Minor changes should be thoroughly documented and follow some type of standard cadence, as this can help maintain the audit trail and visibility of the changes. All changes should still be tested, even if they are minor, as they can have unexpected impacts on other parts of the system or introduce bugs or security issues. Downstream environments will not be automatically updated when production changes are made, so it is important to have a strategy to keep them in sync and avoid conflicts or overwrites. Minor changes do not need to be documented and can be made at any time is a wrong statement, as it can lead to poor governance and lack of accountability. CI/CD is not required to successfully manage minor changes, although it can help automate and streamline the process. See  Application Lifecycle and Deployment  for more details.

Multiple triggers on the same object can cause conflicts and performance issues. Multiple unit test failures can indicate poor code quality and lack of maintenance. Duplicated logic across Visualforce pages and Apex classes can lead to inconsistency and redundancy.

The best practices to support UC’s new package development strategy are to test developed packages in test environments before installing to production, and to consult the metadata coverage report to identify features supported by packages. Testing packages in test environments can help to ensure the quality and functionality of the packages, as well as to identify and resolve any issues or dependencies before deploying to production. Consulting the metadata coverage report can help to determine which features can be included in packages, and which ones need to be deployed using other methods. Version control still needs to be used, as packages do not manage all the code and configuration, but only the components that are part of the package. Moving everything in the existing codebase to a single monolithic package is not a good practice, as it reduces the modularity, maintainability, and reusability of the code. It is better to create smaller packages that are focused on specific features or functionalities.

The best practice for releasing near peak business periods is to avoid doing so, as it can cause disruption and risk to the business operations. Making declarative changes in production, bypassing regression testing, and having developers conduct user acceptance testing are all bad practices that can introduce errors and instability to the system.

The most probable reason why none of the sandboxes can be refreshed is that the org has reached the maximum number of active sandboxes allowed by the license. Deleting the full sandbox used for performance testing will free up one sandbox slot and allow the other sandboxes to be refreshed. The Partial Copy sandbox is not the cause of the problem, as it counts as one sandbox slot. Creating a Salesforce support case or contacting the Salesforce Account Team may not resolve the issue in a timely manner.

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.

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.

Escalating and communicating to stakeholders the risk and mitigating it by allocating additional resources or extending the timeline of the project to support the new requirement based on stakeholders’ input are two actions that should be performed to mitigate the risk. These actions help to manage the scope change and ensure that the project is delivered with the expected quality and functionality.

The recommended strategy for deploying a large volume of metadata is to identify metadata dependencies, create logical groupings, and deploy in the right order. This can help avoid errors and ensure a smooth deployment process.

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

Managed package is the recommended mechanism for releasing an application that can be installed in other Salesforce environments. Managed packages allow for versioning, licensing, and upgradeability of the application. They also protect the intellectual property of the developer by hiding the source code of the Apex classes and Visualforce pages.

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.

 D is the correct answer, as the risk with this plan is that multiple work-streams with dependencies could impact the go-live. If the legacy system upgrade and the new integration are not aligned and coordinated, there could be delays, errors, or failures in the project delivery. A is incorrect, as the deadline being scheduled during a Salesforce release is not a risk, but an opportunity to leverage the new features and enhancements that Salesforce provides. B is incorrect, as the project team using the Waterfall methodology is not a risk, but a choice that depends on the project scope, complexity, and requirements. C is incorrect, as the legacy system team using an Agile methodology is not a risk, but a choice that depends on the project scope, complexity, and requirements. You can learn more about the risk management in the  Project Management Strategies for Salesforce Implementations  module on Trailhead.

Creating transparency by being honest and clear about timing, planning, and obstacles is one of the Scrum principles, as it helps to build trust and collaboration among the team and the stakeholders. Delivering working software is also a Scrum principle, but it does not mean that the software should not be changed if it is working. Respect is another Scrum principle, but it does not imply that a developer should not test the software, as testing is part of the development process. Embracing change is also a Scrum principle, but it does not mean that the scope should change every day, as that would make it impossible to deliver value and quality.

The correct statement for the Staging sandbox in the diagram is that when created or refreshed, the Staging sandbox is a full replica of Production, as it is a full copy sandbox that copies all the data and metadata from the production org. Option B is not true, as the Staging sandbox is not automatically refreshed, but manually refreshed by the administrator. Option C is not true, as Salesforce major releases may occur in Staging and Production at different times, depending on the sandbox preview window. Option D is not true, as the Staging environment can be updated more frequently than once every two weeks, depending on the sandbox refresh interval.

The best solution to address the problem of user testing taking a long time due to data setup is to include automated sample data during deployment. This way, the users can have realistic and consistent data to test the functionality and performance of the system. Assigning more users to create test data, testing data creation being outside the scope of continuous integration, or training business users to create test data more efficiently are not effective solutions, as they still require manual effort and may result in inconsistent or inaccurate data.

 Three advantages of using the SFDX are: can store code on a local machine, or a version control system; can create scratch orgs; and can install application metadata from a central repository. These advantages can help improve the development experience, as they allow developers to work with source-driven development, use ephemeral and configurable environments, and access metadata components from a shared location. Can quickly deploy metadata using Execute Anonymous is not an advantage of using the SFDX, as Execute Anonymous is a feature of the Developer Console that allows running Apex code, not deploying metadata. Can use native Deployment Rollback Tool to quickly revert to prior state is also not an advantage of using the SFDX, as there is no such tool in the SFDX. See [Salesforce DX] for more details.

 To support application lifecycle methodology, you need tools that can help you manage the source code, automate the deployment process, and track the issues and bugs. A version control repository is a tool that allows you to store, track, and collaborate on the source code of your application. A continuous integration tool is a tool that allows you to automate the deployment of your code to different environments, as well as run tests and validations. An issue tracking tool is a tool that allows you to record, monitor, and resolve the issues and bugs that arise during the development and testing phases. A database management system is a tool that allows you to store, manipulate, and query data, but it is not directly related to application lifecycle methodology. A middleware is a software layer that facilitates communication and data exchange between different applications, but it is not directly related to application lifecycle methodology either.

The advice that a technical architect should provide in a Change Advisory Board meeting is troubleshooting strategies for deployment issues.  This is because the Change Advisory Board is responsible for reviewing and approving changes to the IT environment, and the technical architect should provide guidance on how to resolve any potential problems that may arise during the deployment process 1 . The other options are not relevant for the Change Advisory Board meeting, as they are more related to the requirements analysis, design, or testing phases of the development lifecycle.

To move to the package development model, the administrator must enable both the Dev Hub and the Second-Generation Managed Packages in setup. The Dev Hub is the main org where the administrator can create and manage scratch orgs and packages. The Second-Generation Managed Packages are the new format of packages that support modular development and versioning. The Unlocked Packages are a type of second-generation packages that are not tied to a namespace and can be installed and customized in any org. The Source Tracking for Scratch Orgs is a feature that allows the administrator to track the changes made in a scratch org and push or pull them to or from a source repository.

The architect should recommend creating two second generation managed packages with the same namespace and setting the methods that should be shared with the @namespaceAccessible annotation. This will allow the Sales team to access the specific functions of the Service product without exposing them to other teams or customers. Creating two managed packages with different namespaces will not allow the Sales team to access the Service functions, unless they are declared as global, which will expose them to everyone. Creating a managed package with both products will not allow the separation of the products and the control of the functions. Creating an authentication function in the Service package will add unnecessary complexity and overhead to the solution.

 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.