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

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.

A, C, and E are the correct answers, as Force.com Migration Tool, Source Control Tool, and Continuous Integration Build Tool are the tools that should be used to enable a continuous integration process to help manage code quality. A continuous integration process is a practice that involves merging code changes from multiple developers into a common repository, and then testing and validating them automatically, before deploying them to the target environment. Force.com Migration Tool is a tool that uses the Metadata API to retrieve and deploy metadata components, such as code, from one org to another. Source Control Tool is a tool that manages the versions and changes of the code, and allows for collaboration and integration among the developers. Continuous Integration Build Tool is a tool that automates the testing and deployment of the code, and ensures that the code meets the quality and functionality standards. B is incorrect, as Full Sandbox Environment is not a tool that should be used to enable a continuous integration process, as it is a copy of a production org that is used for development and testing purposes, but not for merging, testing, or deploying code changes. D is incorrect, as Project Management Tool is not a tool that should be used to enable a continuous integration process, as it is a tool that helps to plan, organize, and track the progress of the project, but not to manage, test, or deploy code changes. You can learn more about these tools in the Continuous Integration and Continuous Delivery module on Trailhead.

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.

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.

Test classes should execute under various profiles to ensure that the code works for different user permissions and sharing settings. Test data must have positive as well as negative data to cover all possible scenarios and edge cases.

 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.

 D is the correct answer, as the Agile methodology is the best way to handle a project with a fixed deadline and a changing scope, such as retiring a business-critical application that will no longer be supported. The Agile methodology allows for frequent feedback, iterative development, and adaptive planning, which can help to deliver a working solution on time and within budget. A is incorrect, as executive leadership is not a methodology, but a role that can support the project. B is incorrect, as a requirements traceability matrix is a tool that can help to track the requirements and their fulfillment, but not a methodology. C is incorrect, as a business continuity plan is a document that outlines how to resume business operations in the event of a disruption, but not a methodology. You can learn more about the Agile methodology in the Agile Basics module on Trailhead.

According to the [Salesforce Performance Testing Guide], performance tests must be run in a sandbox, a business justification must be provided to Salesforce, and performance tests may be run without advanced notice, but Salesforce will not store performance logs. Salesforce does not need to be informed 7 days before starting performance tests, and Salesforce will not monitor test activity to ensure there are no issues with Salesforce Services.

The development model that is optimized for this need is to use unlocked packages to deploy the global code and allow each country to create its customized unlocked package extensions. This model can help maintain the global standardization and consistency of the code, while also providing the flexibility and autonomy for each region to customize some aspects of the code for their specific needs. Unlocked packages are a type of second-generation packaging that can be created and installed using the Salesforce CLI or APIs, and can be upgraded or uninstalled as needed. Unlocked package extensions are a type of unlocked packages that can depend on and extend another unlocked package or a managed package. See Unlocked Packages 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 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.

The best approaches for UC to consider are B and C, as they both involve agile methodologies that can accommodate changing requirements and deliver value to the end users in an iterative and collaborative way. Option B is a good approach, as it allows UC to scope and estimate the project, identify the minimum viable product, and co-create the design with the project stakeholders using a product backlog and sprints2. Option C is also a good approach, as it allows UC to gather the remaining requirements and complete the architecture and design, then initiate the build/test processes with frequent reviews by the stakeholders, and perform acceptance testing and validate compliance with regulatory requirements3. Option A is not a good approach, as it involves a waterfall project that is rigid and sequential, and may result in re-work and delays if the requirements change or conflict4. Option D is not a realistic approach, as it assumes that budget and timeline will not be a factor with an agile methodology, which is not true, as agile projects still need to have clear scope, budget, and timeline constraints

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.

 A and C are the characteristics of an effective communication plan, as they enable feedback, collaboration, and transparency among the stakeholders. B is not a characteristic of an effective communication plan, as it does not account for changes in the stakeholder list or their communication preferences. D is not a characteristic of an effective communication plan, as it limits the information sharing and trust among the stakeholders.

The best way to stop the rollbacks from happening is to ensure report metadata is exported daily and that it is merged into the developer branches before the next release. This way, the reports and dashboards will be up to date and consistent across all environments. Using a third-party data warehouse is not a solution, as it does not address the root cause of the rollbacks. Removing the executive’s ability to change reports is not a good practice, as it limits their flexibility and autonomy. Backing up and reimporting the reports before and after the release is not a reliable or scalable solution, as it can introduce errors and inconsistencies.

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.

 The Metadata API is mainly used for file-based deployment, such as deploying an application from a Developer Edition org to the AppExchange, or from a sandbox org to a production org. The Ant Migration Tool is a wrapper around the Metadata API, so it is not a direct use case for writing code to call retrieve() and deploy() methods. The Salesforce CLI (SFDX) uses the Source-Driven Development model, which relies on the source code as the source of truth, rather than the Metadata API.

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.

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 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.

Facilitating the design of a prioritization model with the stakeholders is the best way to overcome the problem of having many backlog items and competing stakeholders who cannot agree on priority. A prioritization model is a framework that helps the stakeholders evaluate and rank the backlog items based on various criteria, such as value, urgency, effort, risk, etc. By using a prioritization model, the stakeholders can have a clear and objective way of deciding which items are more important and should be done first. Organizing a sprint planning meeting, taking over prioritization, or allowing the delivery teams to pick the work are not effective solutions, as they do not address the root cause of the problem or involve the stakeholders in the decision-making process.

Designing the right sandbox strategy for the release is a best practice, as it helps to ensure the quality and consistency of the code/configuration across different environments. Regression testing is mandatory for each release, as it helps to verify that the existing functionality is not broken by the new changes. Maintaining a pre/post deployment checklist for each release is a best practice, as it helps to track the tasks and dependencies for each deployment. Release sign-off is not only required for Production, but also for other environments such as UAT and Staging. Publishing a release calendar for each phase of the release is not a best practice, as it may change due to unforeseen circumstances and create confusion.

 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.

Two software development methodologies that an architect should suggest to solve the issue of visibility are Scrum and Kanban. Scrum is based on the value of openness, which means that the team members and stakeholders share information and feedback regularly and transparently. Kanban is based on the principle of making everything visible, which means that the team uses a visual board to track the progress and status of the work items. Waterfall is not a good methodology for visibility, as it does not allow for frequent communication and feedback. DevOps is not a methodology, but a culture and practice that aims to improve collaboration and delivery across the software development lifecycle.

The optimal way to store the service centers as technical reference data is to add them to a custom metadata type. Custom metadata types allow you to create, update, and deploy records that are defined by a custom object. Custom metadata types are similar to list custom settings, but they have some advantages, such as being deployable, queryable, and packageable. Hierarchical custom settings are not suitable for storing multiple records of the same type, and defining a new custom object with a picklist field is unnecessary and inefficient.

 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.

A workflow and a trigger are considered minor changes that do not require alignment with a Salesforce major or patch release. However, they still need proper testing, training, and change management before being deployed to production. Therefore, the architect should plan this as a minor release with training and change management.

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

The best strategy to delete the day’s test data in a partial copy sandbox every night is to execute a batch job that deletes all records created on the day. This way, you can automate the process of cleaning up the test data and avoid manual work. Manually deleting all records individually is time-consuming and error-prone. Creating a new developer copy sandbox every night is unnecessary and wasteful, as developer copy sandboxes have limited storage and functionality. Refreshing the sandbox every night is also not feasible, as partial copy sandboxes have a refresh interval of 5 days.

The best deployment strategy for UC to use in this environment is to refresh the developer’s sandbox, develop changes, refresh the common sandbox, deploy to the common sandbox, test changes, as this will ensure that the developer’s sandbox has the latest production data and metadata, and that the common sandbox has the latest production data and metadata as well as the developer’s changes, before testing and deploying to production. Option B is not correct, as refreshing the developer’s sandbox after testing the changes will erase the changes and make them unavailable for deployment to the common sandbox. Option C is not correct, as refreshing the developer’s sandbox after developing the changes will erase the changes and make them unavailable for deployment to the common sandbox. Option D is not correct, as refreshing the common sandbox before developing the changes will make the common sandbox out of sync with the production data and metadata.

The Tooling API is the best choice for the team that wants to use SOQL queries to retrieve and make changes to smaller pieces of Salesforce metadata through their Java application. The Tooling API provides access to metadata objects such as Apex classes, triggers, workflows, validation rules, custom objects, and fields. It also supports CRUD operations, as well as executing anonymous Apex code. The other APIs are not suitable for this use case, as they either deal with larger metadata components (Metadata API), user interface components (User Interface API), or data records (Any Salesforce API).

 A Requirements Traceability Matrix is a document that links requirements to their sources and test cases, as well as the components that implement them. By using this artifact, a developer can easily find the purpose of an Apex class and the requirement it fulfills.

 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 testing types that an architect should recommend to ensure users don’t face platform slowdowns during peak business hours are: stress testing and performance testing. Stress testing is the process of testing the system under extreme load conditions, such as a large number of concurrent requests, to determine its breaking point and identify any potential bottlenecks or failures. Performance testing is the process of testing the system under normal or expected load conditions, such as the average number of requests per day, to measure its response time, throughput, and resource utilization. These testing types can help ensure that the web service can handle the expected volume and frequency of requests, and that it meets the performance and reliability requirements. Unit testing is not a testing type that an architect should recommend for this scenario, as it is the process of testing individual units of code, such as methods or classes, to verify their functionality and logic. Load testing is also not a testing type that an architect should recommend for this scenario, as it is the process of testing the system under a specific load condition, such as a fixed number of requests, to evaluate its behavior and performance. See Testing RESTful Web Services for more details.

: 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 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.

 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.

The usual symptoms of inadequate negative tests are the ones that indicate that the code is not handling the possible errors or exceptions that may occur in different scenarios. For example, when an Apex batch job runs at a scheduled time, an increased number of Apex execution errors occur over all1, this means that the code is not handling the possible concurrency issues, governor limits, or data quality issues that may arise when the job runs. Similarly, when an Apex process runs into an un-handled exception when an HTTP callout has an unexpected status code in the response body1, this means that the code is not handling the possible network issues, authentication issues, or API errors that may occur when making the callout. Another symptom is when developers constantly ask the testers for a screenshot of the error and the exact steps of reproducing the error1, this means that the code is not logging the error details or providing meaningful error messages to the users. Option A is incorrect because turning to the debug log for details of the failed Apex executions is not a symptom of inadequate negative tests, but a normal practice of debugging the code. Option E is incorrect because the delivered user interfaces are not meeting the expectations of the business users is not a symptom of inadequate negative tests, but a symptom of poor user interface design or incomplete requirements.

The architect should suggest the following actions to help UC discover the failing unit tests earlier: Train the administrators to make their changes in a special “admin changes” sandbox, and then promote to production, and ensure a metadata backup is committed to version control every day and a diff published to the release team. Training the administrators to use a sandbox can help prevent direct changes to production that can break the code or the unit tests. Ensuring a metadata backup and a diff can help identify any changes that have been made to production and compare them with the source of truth.

This is the correct answer because a partial copy sandbox can provide a subset of production data that is refreshed every 5 days. This way, the user acceptance and functional teams can test independently in isolation, and on current production data that was modified within the last week. A developer pro sandbox has a limited data storage and cannot store enough data for testing. A developer sandbox has no data and is only suitable for development and testing of code. A full sandbox can provide a complete copy of production data, but it can only be refreshed every 29 days, which may not meet the requirement of testing on data that was modified within the last week.

How to test existing functionality to ensure no regressions are introduced is a decision that the Architect should make when planning for releases, as it is part of the quality assurance process and helps to ensure that the new changes do not break the existing functionality. When to test a new UC feature release is also a decision that the Architect should make when planning for releases, as it is part of the release schedule and helps to coordinate the testing activities with the development and deployment activities. Whether Salesforce will wait to upgrade the pod until after a UC release is complete is not a decision that the Architect can make, as it is determined by Salesforce and depends on the release window and the pod assignment. How to roll back to the previous Salesforce release if there are issues is not a decision that the Architect can make, as it is not possible to roll back to a previous Salesforce release once the upgrade is done.

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.

 Refreshing a Partial Copy sandbox every weekend and including an appropriate sandbox template will allow UC to train the users on samples of production data and delete all the data generated during the training session at the end of the week. Loading data using data loader is not necessary if the sandbox template includes the relevant data. Developer Pro sandboxes have limited storage and may not be able to accommodate the data needed for the training.

The deployment script will fail because the new field is not known for the previous API version 35. The Metadata API version determines which components and fields are available for deployment. If a component or field is introduced in a later API version than the one used for deployment, it will not be recognized and will cause an error.

 Design standards can help ensure consistency and quality of the code and configuration across multiple project teams. They can also prevent design conflicts and reduce technical debt.

The first step in establishing a governance framework is to identify the relevant stakeholders from within the organization to obtain their goals and objectives. This will help to define the scope, roles, responsibilities, and processes for managing the Salesforce initiatives. The other options are possible steps to take later, but not the first one.

This is the correct answer because some components, such as custom settings, user permissions, and email templates, cannot be deployed via the Metadata API. Therefore, these components should be documented and manually deployed or configured in the target environment.

 Executing all test classes in sandboxes can help identify and fix any errors or failures before deploying to production. Executing selected test classes in production can help reduce the deployment time and avoid running unnecessary tests.

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.

The problem is that UAT is on a preview release and SIT is not. A preview release is a version of Salesforce that contains the features and enhancements that will be available in the next major release. Preview releases are usually available a few weeks before the official release date, and they are assigned to a subset of instances. If UAT and SIT are on different instances, they may have different release versions, which can cause deployment issues. For example, if UAT has a preview release that contains some new metadata types that are not available in SIT, then deploying those metadata types from SIT to UAT will fail. To avoid this problem, the architect should check the Sandbox Preview Guide1 and the Release Notes2 to see if there are any changes that affect the deployment, and refresh and redeploy the sandboxes accordingly. There is a problem, and it is not expected behavior. Using the DX command line instead will not solve the problem, as it will still encounter the same version mismatch. SIT is not on a preview release and UAT is not, as that would not cause any deployment issues.

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.

The architect should recommend using Git to create a release branch from the develop branch. All fixes must be made in the release branch. After deployment, merge release with develop. This strategy allows the team to isolate the changes that are ready for deployment from the changes that are still in progress. It also ensures that the fixes are applied to both the release and the develop branches. The other options do not follow the best practices of Git branching and merging.

A virtual Kanban board tool is a good way to increase transparency and collaboration among agile development teams, as it allows them to visualize their work, track their progress, and identify any bottlenecks or issues. A daily stand-up meeting, a daily email, or a shared spreadsheet are not as effective or efficient as a Kanban board tool.

Refreshing a sandbox during the release preview window to ensure they have the upcoming release is a step that the team at UC should take to prepare for the new Salesforce release, as it allows them to test their application in an environment that matches the production environment after the upgrade. Running regression tests in an upgraded sandbox to detect any issues with the upgrade is also a step that the team at UC should take to prepare for the new Salesforce release, as it helps them to verify that the existing functionality is not affected by the new features or changes introduced by the upgrade. Reviewing the release notes for automatically-enabled features and technical debt is also a step that the team at UC should take to prepare for the new Salesforce release, as it helps them to understand the impact and benefits of the new features or changes, as well as to identify and resolve any technical debt that may cause issues or conflicts with the upgrade. Contacting Salesforce to schedule a time to upgrade the full sandbox is not a step that the team at UC should take to prepare for the new Salesforce release, as it is not possible to request a specific time for the upgrade of the full sandbox, which is determined by Salesforce and depends on the release window and the pod assignment. Upgrading any SOAP integrations to the newest WSDL as early as possible is not a step that the team at UC should take to prepare for the new Salesforce release, as it is not necessary to upgrade the SOAP integrations to the newest WSDL, unless they want to use the new features or fields introduced by the upgrade. The SOAP integrations will continue to work with the previous WSDL versions, as they are backward compatible.

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.

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.

 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.

The architect should recommend that UC start a citizen development program to minimize additional costs and allow UC to accomplish more from the backlog. A citizen development program is a way of empowering non-technical users to create and deploy simple applications using low-code or no-code tools, such as Salesforce Platform. This can help UC leverage the skills and knowledge of their existing workforce, reduce the workload of the development team, and deliver value faster to the business.

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.

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.