#salesforce sandbox dx

[abiyaabi]

Understanding the Salesforce DevOps Engineer Role

The Salesforce DevOps Engineer is a specialized role that merges the worlds of development, operations, and system administration within the Salesforce ecosystem. As organizations increasingly adopt Salesforce to manage customer relationships, the need for efficient, automated processes to deploy and maintain Salesforce applications has grown. For those looking to enhance their skills, Salesforce Online Training & Placement programs offer comprehensive education and job placement assistance, making it easier to master this tool and advance your career.

A Salesforce DevOps Engineer is responsible for streamlining these processes, ensuring faster and more reliable delivery of updates, and helping teams collaborate effectively.

Here’s an in-depth look at the role of a Salesforce DevOps Engineer:

1. Automating Development and Deployment Workflows

One of the core responsibilities of a Salesforce DevOps Engineer is automating various development and deployment processes. Using tools like Salesforce DX, Jenkins, and Git, a DevOps engineer helps to establish Continuous Integration (CI) and Continuous Delivery (CD) pipelines. This automation reduces manual interventions, accelerates development cycles, and ensures that Salesforce applications can be deployed with minimal errors and disruptions.

2. Version Control Management

Salesforce metadata changes (such as code, configurations, or customizations) are managed through version control systems like Git. The DevOps engineer oversees the integration of Salesforce environments with version control, ensuring that developers can manage changes, track history, and collaborate efficiently. This also allows for easier rollback in case of errors or bugs, maintaining a stable codebase.

3. Salesforce Environment Configuration and Management

Salesforce DevOps Engineers manage multiple environments, such as developer sandboxes, testing, staging, and production environments. They ensure that these environments are configured correctly and aligned with the production system. They also handle data migration, maintain consistency between environments, and manage metadata deployments. This is crucial for maintaining the stability and integrity of Salesforce applications across various stages of development.

4. CI/CD Implementation

Salesforce DevOps Engineers design and implement CI/CD pipelines, which automate the testing, building, and deployment of Salesforce code. The goal is to ensure that code changes are automatically tested and deployed to the appropriate environments without manual intervention. This helps in reducing deployment errors, increasing release frequency, and improving overall product quality. With the aid of Best Online Training & Placement programs, which offer comprehensive training and job placement support to anyone looking to develop their talents, it’s easier to learn this tool and advance your career.

5. Monitoring and Troubleshooting

Once applications are deployed, DevOps Engineers are responsible for monitoring system performance and ensuring the stability of Salesforce applications. They use monitoring tools to track the health of the system, detect performance issues, and identify bottlenecks in the pipeline. Troubleshooting issues quickly and efficiently is crucial to keeping Salesforce environments up and running smoothly.

6. Collaboration Across Teams

A Salesforce DevOps Engineer works closely with developers, Salesforce administrators, business analysts, and operations teams. They help ensure smooth communication and collaboration between teams by maintaining an efficient deployment pipeline. This alignment between development and operations is essential to meeting business objectives and reducing the time it takes to deliver features or updates.

7. Security and Compliance

Security is an integral part of the DevOps process. Salesforce DevOps Engineers are responsible for ensuring that all deployment processes adhere to best practices in terms of security and compliance. This includes managing user permissions, securing sensitive data, and ensuring that deployment processes meet regulatory standards. By doing so, they protect both the application and the data it handles.

8. Optimizing the Salesforce Development Lifecycle

DevOps Engineers also work to continuously optimize the Salesforce development lifecycle. They identify opportunities to improve deployment processes, reduce cycle times, and eliminate inefficiencies. They may introduce new tools, refine processes, and gather feedback from other team members to continually improve the overall workflow.

9. Disaster Recovery and Backup Management

Part of maintaining a stable Salesforce environment involves planning for potential disasters. Salesforce DevOps Engineers are responsible for implementing backup and disaster recovery strategies, ensuring that data is backed up regularly, and systems can be restored in case of failure. This is essential for minimizing downtime and protecting critical business information.

Conclusion

The Salesforce DevOps Engineer plays a pivotal role in ensuring that Salesforce applications are deployed quickly, securely, and efficiently. By automating workflows, managing version control, and ensuring seamless collaboration between development and operations teams, they help organizations maximize the potential of their Salesforce platforms. As businesses continue to rely on Salesforce to power their customer relationship management, the role of the Salesforce DevOps Engineer will only become more integral in driving successful deployments and system performance.

[winklix]

Effective Strategies for DevOps Teams Deploying Salesforce Agentforce 2.0

Salesforce Agentforce 2.0 is a powerful platform designed to streamline customer service operations and enhance agent productivity. For DevOps teams tasked with implementing and managing this solution, adopting best practices is essential to ensure a smooth deployment, optimized performance, and long-term success. Below are key recommendations to guide your DevOps team through the implementation process.

1. Understand the Platform and its Capabilities

Before diving into the implementation, invest time in understanding the core features and functionalities of Agentforce 2.0. Leverage Salesforce’s documentation, training modules, and community resources to:

Learn about Agentforce’s key features like Omni-Channel Routing, AI-driven insights, and Workflow Automations.

Familiarize yourself with the platform’s integration points, especially if you’re connecting it with existing CRM or ITSM systems.

Identify configuration versus customization opportunities to align with business needs.

2. Collaborate Early with Stakeholders

Success starts with collaboration. Engage with stakeholders such as customer support managers, IT teams, and end-users early in the process. Conduct workshops or discovery sessions to:

Gather requirements and prioritize features.

Understand existing workflows and pain points.

Ensure alignment between technical implementation and business objectives.

3. Adopt an Agile Implementation Approach

Given the iterative nature of most Salesforce deployments, an agile approach ensures continuous improvement and quick feedback. Key practices include:

Breaking down the implementation into manageable sprints.

Setting up regular sprint reviews with stakeholders.

Using feedback loops to refine features before full deployment.

4. Automate CI/CD Pipelines

Continuous Integration and Continuous Deployment (CI/CD) are critical for a seamless implementation. Use tools like Salesforce DX, Git, and Jenkins to:

Version control metadata and customizations.

Automate testing and deployments across environments.

Reduce the risk of manual errors while improving deployment speed.

5. Ensure Data Integrity and Security

Data is at the heart of any Salesforce application. Prioritize data integrity and security by:

Conducting thorough data audits before migration.

Setting up field-level, object-level, and record-level security as per organizational policies.

Using tools like Salesforce Shield for encryption and event monitoring.

6. Leverage Sandbox Environments for Testing

Sandbox environments are invaluable for testing configurations and integrations without impacting production data. Follow these guidelines:

Use Full or Partial Copy Sandboxes to simulate real-world scenarios.

Perform rigorous User Acceptance Testing (UAT) with actual stakeholders.

Validate integrations with external systems thoroughly.

7. Utilize Built-in AI and Analytics Features

Agentforce 2.0’s AI-driven tools, like Einstein AI, provide actionable insights to improve customer service. Ensure your implementation maximizes these features by:

Training models with relevant data to enhance predictions.

Setting up dashboards to monitor agent performance and customer satisfaction.

Using analytics to identify trends and optimize workflows.

8. Train Your Team and End Users

The best technology is only as effective as its users. Invest in comprehensive training programs:

Provide role-specific training for agents, admins, and managers.

Create a knowledge base with step-by-step guides and FAQs.

Schedule refresher sessions post-launch to address new updates or challenges.

9. Monitor Performance and Gather Feedback

After deployment, ongoing monitoring and feedback collection are vital. Use tools like Salesforce’s Health Check and AppExchange monitoring solutions to:

Identify bottlenecks in workflows.

Monitor system performance metrics.

Continuously gather feedback from agents and stakeholders to improve processes.

10. Plan for Scalability and Future Upgrades

Agentforce 2.0 is designed to grow with your organization. To future-proof your implementation:

Regularly review and update workflows as business needs evolve.

Stay informed about Salesforce’s roadmap and new feature releases.

Plan for scalability, ensuring infrastructure and licenses can support future growth.

Conclusion

Implementing Salesforce Agentforce 2.0 requires a thoughtful, well-coordinated approach that aligns technical execution with business objectives. By following these best practices, DevOps teams can ensure a successful deployment, delivering value to both customer service agents and the organization as a whole.

Remember, the implementation process is not a one-time effort but an ongoing journey toward innovation and excellence in customer service. Stay agile, stay collaborative, and stay committed to continuous improvement.

[algoworkstechnology]

Top 7 Best Practices For Salesforce Development

In 2017, Salesforce came up with its DX version with features like Salesforce CLI, a new sandbox, and best practices for source-driven development. That made helping hands from Salesforce consulting services California more than optional.

The need for best practices arises for bringing synergy into the whole ecosystem and helping create a faster solution that satisfies the particular requirements of each business with its extensive features and customization options.

What Is Salesforce Development?

The Salesforce ecosystem has multiple products covering Marketing, Sales, Services, Analytics, Commerce, and Slack. Under Salesforce development, you build solutions with the help of no-code tools and code. To design, create, and install Salesforce products, several stakeholders work in a seamless way.

Best Practices For Salesforce Development

Plan Everything In Advance

For better and faster Salesforce development, planning is as important as implementation. Certified Salesforce consulting partners emphasize that the best way to plan everything is through brainstorming and SWOT analysis. This not just brings better clarity in the development process but also minimizes the uncertainties that may come later on.

Focus On Process Documentation

Irrespective of our intelligence, we tend to forget things. That's why documenting the process in the form of an SOP, guidebook, etc., is a good choice. These written documents work like a reference point for everyone involved in the development process.

Every step of the monitoring, auditing, and compliance process should have written documents before moving on to development.

Understanding Salesforce Architecture

In order to design and deliver solutions in the Salesforce ecosystem, architectures are used. The architecture assists developers in choosing the best options as per their needs. Thus, prior to beginning any development activities with the aid of Salesforce consulting services, it is essential to comprehend the Architecture. 

Use Of Development Tools

Time and resources required in the Salesforce development are directly proportional to the choice of tools. Take a good amount of time to evaluate all the alternatives and seek help from Salesforce consulting company in California whenever necessary.

Use Of Sandbox

Each developer must utilize sandboxes appropriately based on their own requirements. There are numerous Sandboxes in the Salesforce development process with or without data. These Sandboxes provide choices for conveniently tracking changes and advancement in Salesforce development.

Abidance To Coding Conventions Is Must

A Salesforce developer needs to create the code in a readable manner, along with adhering to accepted coding standards and naming conventions. Salesforce consulting services California always suggests developers against complicating the process through the use of difficult frameworks, libraries, and more.

Give Priority To Testing Before Deployment

Skilling the testing stage is an invitation to negative results in the short term or long term. Who wants to sabotage the growth process or do the correction later on? To save time and effort, it is standard practice to test the code using automated test scripts or tools before deployment.

Final Thoughts

You want better and faster results from Salesforce, right? For that, the development team needs to keep the process simple and consistent, along with adhering to the best practices continuously.

Like others, you also need a Salesforce consulting partner having the experience to help you follow the best practices. Feel free to connect with Algoworks; they’re best for consultation, customization, and integration in Salesforce.

Summary

Salesforce’s trust is built into the infrastructure, network, application services, and every other layer of platforms enabling over 150,000 businesses worldwide. That's possible due to every stakeholder following best practices. Find best practices at Algoworks.

[winsurtech]

In a regular Salesforce development lifecycle, application developers use different sandboxes to create and test changes. With Salesforce DX, we can change the way our team members work. Instead of collecting together the state of various environments to get the latest versions of code or metadata, the team can get the latest versions from a centralized source control system, like Git or Subversion. This way of managing development artifacts that is code and other customizations is called source driven development.

[hrtechmagazine]

Source of Truth in Salesforce DX and Managing the Declarative Changes

Source of Truth in Salesforce DX and Managing the Declarative Changes

Salesforce DX offers the developers an option to custom code the apps locally and then first deploy it to Sandbox Org or Production Org from the command line interface. Bust as any expert developer may think, no development process is complete without a source of truth.

It is okay to make any changes in the IDE of your choice, but what will happen when multiple developers work on the same file…

[hrtechweekly]

Source of Truth in Salesforce DX and Managing the Declarative Changes

Source of Truth in Salesforce DX and Managing the Declarative Changes

Salesforce DX offers the developers an option to custom code the apps locally and then first deploy it to Sandbox Org or Production Org from the command line interface. Bust as any expert developer may think, no development process is complete without a source of truth.

It is okay to make any changes in the IDE of your choice, but what will happen when multiple developers work on the same file…

[redbook-at-dreamforce-2017]

Dag 3 op Dreamforce: Advanced Trail Blazers

Dreamfest was een mooie afsluiting van de tweede dag. Het optreden van Alicia Keys en Lenny Kravitz in het stadion van de San Francisco Giants was een leuke afwisseling van activiteit.

Vandaag is het alweer de derde dag van Dreamforce en hebben we verschillende sessies op het programma staan. We beginnen de ochtend met een sessie over Salesforce DX, een nieuwe development tool van Salesforce. We krijgen een presentatie van Mike Tetlow, de CTO van TaskRay. Taskray is een ISV van Salesforce die al een tijdje gebruikt maakt van DX voor hun development. In de presentatie wordt verteld over zogenaamde Scratch Orgs. Een Scratch Org moet gezien worden als een soort sandbox voor je sandbox die het mogelijk maakt om verschillende custom code te mergen naar een org. Wanneer je met meerdere developers op een project werkt maakt dit het proces van het implementeren van verschillende features gestroomlijnder. Het geeft je de mogelijkheid om Git branches te gebruiken binnen Salesforce.

Zoals beloofd hebben we vandaag meer informatie kunnen krijgen over Health Cloud en wonen we hier een sessie van bij. Een relatief nieuw product van Salesforce gemaakt voor de gezondheidszorg die boven op Service Cloud draait. De functionaliteit van Salesforce Health Cloud vertoont veel gelijkenissen met het Elektronisch Patiënten Dossier, waarbij de medische historie van een patiënt is weergegeven en een duidelijk behandeltraject kan worden opgesteld. Wat betreft privacy is dit natuurlijk een heel gevoelig product, maar wanneer het mogelijk zou zijn, zou het veel perspectief en kansen bieden voor de zorgsector en zou dit zomaar een van de grootste producten kunnen worden op de markt.  

Ook krijgen we vandaag een demo van Marketing Cloud. Op het eerste gezicht lijkt Marketing Cloud veel op Pardot, maar er zijn zeker verschillen. Waar Pardot een goede tool is om individuele betrokkenheid te meten bij B2B, richt Marketing Cloud zich meer op het uitsturen van grote volumes marketingcommunicatie naar een bredere doelgroep bij B2C. Daarnaast biedt Marketing Cloud meer flexibiliteit zoals het versturen van SMS berichten en het integreren met API’s. Hiermee laat het zien dat het makkelijker te integreren is met andere producten en het daarmee een heel sterk op zichzelf staand product is.

Na een geslaagde dag in het Moscone Center stappen we even uit The Dream Valley en begeven we ons naar de bekende Fishermans Warf. Hier hebben we nog even genoten van het mooie uitzicht vanaf de bay van San Francisco en maken ons op voor de laatste dag.                  

[tak4hir0]

Welcome to open-force.org! This is a maker space for developers and others in the Salesforce.com ecosystem to share code with each other. Think of open-force as a workshop where people like you are hanging out, tinkering with things they are passionate about. Maybe you'd like to chip in on a project you find interesting, or maybe you'd like to bring your own project into the workshop? This website includes a searchable index of open source projects that exist in Salesforce-land. You can browse these projects with the tool below. We're happy to list any Salesforce-related open source project; send an email to dev@open-force.org to have your project added to the index. There are some companion resources to this website: if you'd like a place to host your project, we give out repositories in our public GitHub at https://github.com/open-force. To have a repository created, send an email to dev@open-force.org.We have a community of collaborators that hang out in a slack channel over on the GoodDaySir podcast slack. Sign up for the slack group at https://www.gooddaysirpodcast.com/community, and find us in the #open-force channel.We're glad you're here. We love sharing knowledge and code, and we hope you will participate in our open source movement on the Salesforce platform! Want to make this website even better? It's open-source (you're shocked, I'm sure), so go ahead and submit a pull request: https://github.com/open-force/website. A utility class that allows serialization/deserialization of reserved keywords Apex Wrapper for the Salesforce Metadata API Apex463463703BSD 3-Clause "New" or "Revised" License61A simple framework for building Restful API on Salesforce Platform-Event-based Apex logger for unified logging over transaction boundaries Apex797928MIT License Define "Templates" to match and parse URI. Apex660 A collection of apex classes that can be useful for development on the salesforce platform Apex11113MIT License Advanced Techniques for Salesforce DX Adoption Framework Apex676722BSD 3-Clause "New" or "Revised" License7This project is archived, please see the readme for additional resources. JavaScript676676332Apache License 2.0 B.A.S.S. Starter: react / redux / typescript / antd / ts-force / sfdx / webpack / salesforce TypeScript11411419MIT License14Auto-completion for the Cumulus CI CLI for bash Shell110Apache License 2.0 Customized Visual Code Server built from coder/code-server to support Salesforce development using sfdx and other extensions Shell110MIT License A simple bit of Apex to help you investigate which Apex Limits are applied in various execution contexts where Apex can run. Apex551MIT License Python framework for building portable automation for Salesforce projects Python189189156BSD 3-Clause "New" or "Revised" License88Dummy project used to test CumulusCI - CumulusCI will run this project through the whole CI flow to verify everything works RobotFramework88161BSD 3-Clause "New" or "Revised" License7Declarative Rollup Summaries for Lookups Apex451451180BSD 3-Clause "New" or "Revised" License150Salesforce Lightning Design System JavaScript29752975664Other12Salesforce Lightning Design System for React JavaScript615615274BSD 3-Clause "New" or "Revised" License90Common Apex Library supporting Apex Enterprise Patterns and much more! Apex480480326BSD 3-Clause "New" or "Revised" License69Common Apex Library supporting Apex Enterprise Patterns and much more! Apex480480326BSD 3-Clause "New" or "Revised" License69Builder Extension library to fflib_apex-common Apex25259BSD 3-Clause "New" or "Revised" License3An Apex mocking framework for true unit testing in Salesforce, with Stub API support Apex228228135BSD 3-Clause "New" or "Revised" License17An Apex mocking framework for true unit testing in Salesforce, with Stub API support Apex228228135BSD 3-Clause "New" or "Revised" License17[DEPRECATED] Command line tool supporting the Force.com development lifecycle JavaScript10410437MIT License8Generic DI library with support for Apex, Triggers, Visualforce and Lightning Apex15215267BSD 3-Clause "New" or "Revised" License19A structured, extensible logger for Salesforce Apex A native app to support complex Salesforce sharing with quick and easy configuration Automatic Entity-Relationship diagrams and SOQL queries for Salesforce JavaScript23232The Unlicense26A Lightning Component grid implementation that expects a server-side data store. Apex353510MIT License A Salesforce Lightning Component that allows users to show useful links for users on Lightning pages HTML551Apache License 2.01Apex library for HTTP callouts. Apex003Apache License 2.01Image labeller for Salesforce Einstein Object Detection JavaScript334Apache License 2.0 Indicators Lightning Web Component JavaScript17172MIT License8Apex JSON parser to make it easier to extract information from nested JSON structures Apex67678MIT License Lightning Components and Redux: A Predictable State Container for Lightning Apps JavaScript42427MIT License2Lightning component that acts a singleton JavaScript441Apache License 2.0 lodash as a Lightning Web Component JavaScript771 :zap: LWC - A Blazing Fast, Enterprise-Grade Web Components Foundation JavaScript854854180MIT License251The SLDS Illustration component as an App Builder-ready Lightning Web Component. HTML440MIT License Useful LWC components for Salesforce JavaScript15152BSD 3-Clause "New" or "Revised" License11Using Salesforce and Lightning Web Component technology to explore machine learning, using TensorFlow.js and other libraries. JavaScript440 Lightweight, Salesforce specific CI app run on Heroku to build Github repositories configured for CumulusCI Python393916BSD 3-Clause "New" or "Revised" License43CLI tool for processing Salesforce Metadata XML files Shell13131MIT License Salesforce.org's managed package installer Python161611BSD 3-Clause "New" or "Revised" License7The current version of the Salesforce.org Nonprofit Success Pack Apex455455275BSD 3-Clause "New" or "Revised" License383Generic and reusable Lightning service component that retrieves picklist entries (Archived) Apex10105Apache License 2.01PowerShell module for Salesforce SFDX PowerShell000 Pygments lexer for the Salesforce Apex language. Python000MIT License Salesforce open source library with logging framework, trigger framework, feature switches, and advanced monitoring capabilities Apex404011BSD 3-Clause "New" or "Revised" License A custom path assistant built using only Lightning Web Components JavaScript202010MIT License2Salesforce DevTools is a Chrome extension for Salesforce developer, based on everything we need in Salesforce development A simple solution for managing environment variables in salesforce TypeScript26264MIT License4A tool for copying test data into Salesforce sandboxes Not your mother's Salesforce scheduler JavaScript17172BSD 3-Clause "New" or "Revised" License3Apex Library to schedule Unit Test runs Community project to collect and collate recipes for using the Salesforce command line interface (CLI). A lightning component that lets you generate an order w/products from an opportunity record Apex110MIT License Salesforce Lighitng Data table JavaScript552 Utility to provide automated ranking of objects based on values. i.e. Accounts Ranked by Annual Revenue Apex110MIT License Invocable Apex method to allow admins to setup and send slack messages to incoming webhooks Apex551 A native chat application for Salesforce Apex111MIT License Project template for SFDO Django/React/SLDS projects sfdx plugin for browser automation TypeScript616116MIT License5A sfdx plugin to help compare metadata from different environments and provide a user friendly way to merge them. TypeScript990MIT License5Utility for copying files from one dir to another, useful for sfdx Extended Salesforce DX project directory template, designed to support complex projects and managed packages. Shell15615653MIT License10SalesforceDX command to login using username password oauth2 flow 🚀 Declaratively schedule Process Builder, Flows, Quick Actions, Email Alerts, Workflow Rules, or Apex to process records from Reports, List Views, SOQL, or Apex. Apex18718731BSD 3-Clause "New" or "Revised" License32A GUI for managing sfdx orgs TypeScript22222MIT License14Autocomplete script for powershell on windows, for sfdx PowerShell442GNU General Public License v3.01A plugin for splitting and merging Salesforce profiles. Common Apex utility classes and frameworks used by Sirono products 000Apache License 2.0 Common Apex utility classes and frameworks used by Sirono products Apex838324Apache License 2.03A Apex Utility class to Clone a Salesforce SObject & and it's children. Custom Metadata Type Loader, designed for Lightning Experience Apex12121MIT License Website serving various status info for Salesforce.org Python334BSD 3-Clause "New" or "Revised" License9A Lightning app for monitoring streaming events: PushTopic, generic, platform events, CDC events and monitoring events. A Salesforce Lightning Component that allows users to embed a Trello board or a Trello card. More information on the Trello embedding functionality can be found here - https://developers.trello.com/docs/boards and https://developers.trello.com/docs/cards HTML110Apache License 2.01A Salesforce REST Client written in Typescript for Typescript TypeScript38384BSD 3-Clause "New" or "Revised" License28Heroku app that drives the open-force.org website. Check the Readme for how to get your stuff listed. TypeScript996MIT License5A not-that-carefully-maintained list of weird limits you might run across working with Salesforce.com 15151

[tak4hir0]

Portable automation takes the sophisticated build, setup, and test automation used in continuous integration and makes it available everywhere in the application’s lifecycle, for admins, developers, testers, product managers, and support engineers. It’s what lets Salesforce.org develop dozens of managed packages and set up thousands of orgs every month without hitting roadblocks in shared environments or bogging down in infrastructure management. We’ll explore how to create portable automation with CumulusCI, a free, open source tool that builds on Salesforce DX to automate scratch org setup and configuration, seed data into sandboxes and scratch orgs, and deploy apps between environments. We’ll look at the “org problem”, the challenges holding teams back from using effectively applying CI and other development best practices, and how to use portable automation to solve them. And in a live demo, we’ll go from zero to fully-automated managed package in less than fifteen minutes. Whether you’re an end user, consultant, or ISV, you’ll leave with a roadmap for enabling your teams to move fast and innovate without breaking things, while you take your app (or your org) into the next generation of release and change management. Agenda: The trail to production and the org problemThe Salesforce.org solution: portable automation with CumulusCILive demoMetecho: Portable automation for adminsCompleting the picture with MetaCI and MetaDeployTakeaways The org problem All of these roles and systems need Salesforce orgs to work in. Building new orgs is hard. Traditional tools only do metadata setup.What about configuration? Data? Dependency management?What about multiple org shapes for different roles?CI automation is usually not “portable” (CI only). Managing persistent orgs’ state is hard. Challenging to fully synchronize with source controlWeak change managementUsers conflicting with one another What CumulusCI does Builds orgs based on repeatable recipes  Dependency managementPackage or application installationMetadata deployment to tailor orgConfiguration of settingsData seedingAny task achievable with the Salesforce API CumulusCI makes it easy to define fully-realized scratch orgs for each of your roles. Provides tools for each role to use in their orgs Run tests (Apex, Jest, Robot browser and API automation)Develop and deploy code and metadataLoad, modify, and capture data sets CumulusCI makes it easy for developers, admins, and testers to do their work and collaborate in version control. Flows and tasks CumulusCI comes with dozens of built-in tasks and predefined flows.Tasks and flows are configurable in simple text markup.New capabilities can be added in Python. Want to learn more ? Check below recording with demo. Recording. When ? Date     : Sat, Sept 05, 2020 10:00 AM EST (7:30 PM IST) Speaker :  David Reed Where : ApexHours YouTube Further learning If you are new in Salesforce. Please check our free Salesforce Admin and Salesforce Developer training. Please Subscribe to our YouTube channel to get notification for upcoming recording. Thanks Apex Hours 75 total views, 75 views today The post Automate the App Lifecycle with CumulusCI appeared first on Apex Hours.

[tak4hir0]

This is the second post in a two-part series presenting how to work with Developer Sandboxes and the Salesforce CLI. Over the course of this series, we’ll cover: Part 1: Sandbox Management Manage sandboxes with the Salesforce CLI Clone sandboxes instead of creating new ones Initialize sandboxes with a custom Apex class (Beta) Secure your production Org with sandbox-only users Import sample data Refresh outdated sandboxes Delete unused sandboxes Part 2: Metadata Management Prefer the source format over the metadata format Retrieve metadata with the Org Browser Retrieve metadata that do not support wildcards in package.xml (reports, dashboards…) Remove metadata that’s no longer needed Leverage Custom Metadata to pass configuration from Production to your Developer Sandbox Test metadata deployments In this final part, we’ll focus on metadata management for Developer sandboxes, but these best practices can be expanded to any non-source tracked org such as Developer Edition orgs or production orgs. We’ll cover various tools and techniques that you can use to enhance your development workflows. Prefer the source format over the metadata format At a high level, Salesforce orgs are made of three things: The Platform, metadata and data: The Platform is the base infrastructure, tools and services that are provided by Salesforce. Metadata is everything that lets you customize the Platform for your business needs (layouts, source code, permissions, custom objects, fields and so on). Data are the records that are stored in the org. Metadata is what Salesforce developers work on. There are two project formats that developers can work with: Metadata format or source format. The metadata format is the legacy format that was introduced to represent metadata on a filesystem. This format uses large XML files that are designed to be machine readable. This format is used by the Metadata API. With the introduction of Salesforce DX, we introduced the source format. This format splits the metadata into smaller files and intuitive subdirectories. This makes it easier to read and manage in version control. With source format, you can easily collaborate on a project with multiple developers, merge changes with fewer conflicts and review the history of your project. Here’s an example of the same metadata represented in both formats:   As a general rule, the source format is preferable over the metadata format but there are a few common misconceptions around it so let’s clarify a few things before moving on: Source format works with any orgs, it’s not limited to Scratch orgs. What is specific to source-tracked orgs are certain CLI commands such as force:source:pull or force:source:push. There are equivalent commands for metadata deployment to non source-tracked orgs like sandboxes or production orgs ( force:source:retrieve and force:source:deploy for example).   Projects aren’t locked into a specific format: the metadata and source formats can be converted from one to the other. There are two CLI commands that let you convert between the two, respectively force:source:convert and force:mdapi:convert. All CLI commands starting with force:source work with source format and all force:mdapi commands work in metadata format. Always prefer the source format for your projects as it facilitates collaboration and versioning. Retrieve metadata with the Org Browser If you use VSCode, you can use the Org Browser (cloud shaped icon on the left toolbar) to explore the org’s metadata and download selected artifacts in source format with just a few clicks. This feature is amazingly simple and convenient.   Retrieve metadata that doesn’t support wildcards in package.xml When retrieving artifacts with the CLI, you can use a package.xml file to specify the resources that are retrieved. This is generally pretty easy with the use of wildcards (the * symbol). However, some artifacts like reports, dashboards, documents and email templates can’t be retrieved with wildcards because they’re located in folders. You can either retrieve those artifacts by using the Org Browser (see above) or a combination of CLI commands. Here’s an example of how you can retrieve reports in source format using the CLI: List the metadata folder artifacts (ReportFolder type for Report in this example): sfdx force:mdapi:listmetadata -m ReportFolder [ { createdById: '00558000000yFyDAAU', createdByName: 'Philippe Ozil', createdDate: '2020-02-26T12:39:18.000Z', fileName: 'reports/SomeFolder', fullName: 'SomeFolder', id: '00l4H000000eerVQAQ', lastModifiedById: '00558000000yFyDAAU', lastModifiedByName: 'Philippe Ozil', lastModifiedDate: '2020-02-26T12:40:51.000Z', manageableState: 'unmanaged', type: 'ReportFolder' }, ... ] List artifacts for a given folder (in the output of this example we see that there’s a My_User_Report report in the SomeFolder folder): sfdx force:mdapi:listmetadata -m Report --folder SomeFolder { createdById: '00558000000yFyDAAU', createdByName: 'Philippe Ozil', createdDate: '2020-02-26T12:40:08.000Z', fileName: 'reports/SomeFolder/My_User_Report.report', fullName: 'SomeFolder/My_User_Report', id: '00O4H000004U7glUAC', lastModifiedById: '00558000000yFyDAAU', lastModifiedByName: 'Philippe Ozil', lastModifiedDate: '2020-02-26T12:40:08.000Z', manageableState: 'unmanaged', type: 'Report' } Add the artifacts to your package.xml file. You’ll have to specify the artifact fullName (a combination of folder name and artifact name) that you retrieved in the previous command: Retrieve the artifacts in source format with the CLI: sfdx force:source:retrieve -x package.xml This is a rather manual process when doing an initial import, but note that these operations can be chained and automated with custom CLI plugins or scripts. Remove metadata that’s no longer needed Metadata or source deployment only adds new artifacts by default. It’s your responsibility as a developer to do some cleanup and remove unneeded metadata to avoid cluttering your org. If you use VS Code, you can simply right click on a file in the Explorer and select SFDX: Delete from Project and Org.     You can also delete metadata with CLI commands: # Remove a DeleteMe Apex class and a Hello Aura component sfdx force:source:delete -m ApexClass:DeleteMe,AuraDefinitionBundle:Hello # Remove all metadata (in source format) from the 'deleteMeFolder' directory sfdx force:source:delete -p deleteMeFolder Leverage custom metadata types to pass configuration from production to your Developer sandbox While Developer sandboxes are created with no initial data, you can leverage custom metadata types to pass configuration from your production org. Because custom metadata records are no ordinary records, they aren’t considered “data”. This means that they get copied over from the production org to the sandbox. With that special rule in mind, you can set up the following process: Admin configures custom metadata in production Admin creates a new sandbox Metadata and custom metadata records are copied over to the sandbox Apex sandbox initialization class executes automatically Class reads the custom metadata records Class configures the sandbox Here’s a sample project that illustrates how custom metadata lets the production admin configure new sandbox users. This project contains a sandbox initialization Apex class that relies on a custom metadata type to dynamically create sandbox users with specific names and emails. Test metadata deployments You can setup CI to test metadata deployments without modifying the target org. This type of test saves you precious time and eliminates the risk of errors because you do not need to cleanup your sandbox between jobs. Deployment tests are made possible thanks to the checkOnly flag in the metadata deploy command. This option is available in the Salesforce CLI force:source:deploy command with the -c or --checkonly flag. Here’s an example of how you can test the deployment of your local source (force-app folder) and run tests on your sandbox with the CLI: sfdx force:source:deploy -p force-app -c -l RunLocalTests Closing words This concludes our Salesforce CLI Best Practices for Developer Sandboxes series. In this final post we’ve covered CLI best practices for managing metadata in non-source tracked orgs such as Sandboxes, Developer Edition orgs or production orgs. We covered the benefits of the source format, how to retrieve or remove metadata, how to pass configuration from a production org to a Developer sandbox and how to test metadata deployments. We’ll leave you with a CLI command cheatsheet that summarizes the commands we’ve covered in the series:   Try them on your orgs and keep an eye out for the Sandbox source-tracking Beta in Summer ’20. Resources Sandbox management best practices for administrators Salesforce DX Developer Guide Sandboxes Develop Against Any Org Modern Tooling for the Sandbox Development Workflow About the author Philippe Ozil is a Principal Developer Evangelist at Salesforce where he focuses on the Salesforce Platform. He writes technical content and speaks frequently at conferences. He is a full stack developer and enjoys working on robotics and VR projects. Follow him on Twitter @PhilippeOzil or check his GitHub projects @pozil.

[tak4hir0]

Most Salesforce orgs contain a sea of unpackaged metadata. Some customizations are made by hand with the Setup Menu, others are created with Change Sets or the Metadata API. Unpackaged customizations can pile up over time and make the org difficult to manage. Too many customizations can result in slow performance, reduced agility, sluggish adoption, and added complexity. Moving unpackaged assets into packages can solve this problem and add much needed structure to your Salesforce account. When you break your Salesforce org into packages, overall complexity is reduces, which improves corporate agility and speeds the release cycle. This blog discusses techniques that can help you break your Salesforce org into packages. Moving forward with Salesforce DX and Second-Generation Packaging, there are significant benefits to adopting this technology. We discuss the costs and benefits of packaging, the different types of packages that are available, various techniques to identify connected assets, and the technical methods for creating new packages. In conclusion, we discuss a practical roadmap and the best practices for breaking your org into packages. Packaged or Unpackaged? Just to be clear, all of those unpackaged assets in your org aren’t going to magically disappear. The standard objects, tabs, applications, and other metadata provided by Salesforce will live on as unpackaged assets. Standard objects can’t be moved into packages, anyway. All of the reflected customizations from managed packages will appear among the unpackaged assets with a namespace. Unmanaged and unlocked packages will also pour assets into the sea of unpackaged metadata. If the unpackaged assets aren’t going away, then what is the point of organizing them into packages? Here is an analogy that might prove helpful. In the software development world, source code is compiled into object code. Unpackaged assets are kind of like object code. Understanding the architecture and debugging problems at the object code level is difficult because all of the unpackaged assets are mixed together in a flat folder, and Apex Classes from managed packages are obfuscated. Our goal is to select related assets from the unpackaged area and organize them into packages. Packages are kind of like source code. They group related assets together and make everything easier to understand. Costs and Benefits There are many advantages to adopting packages. Bugs and problems are isolated to the package instead of being spread across the entire org. When a project needs to be upgraded or replaced, the package makes entangled assets easier to identify. Packages are the foundation for agile development, enabling smaller groups of developers to focus on more isolated sections of code. Packages can be individually tested in a Scratch Org or developer account. Modular packages can be used to enable multiple orgs and partners. Packages lower cost, increase flexibility, reduce complexity, and improve time to production. But breaking your org into packages is not for everyone. Smaller orgs can often be managed effectively with nothing more than the Setup Menu. Companies that are not customizing Salesforce in a significant way may not feel any pressure to reduce complexity. Refactoring various metadata assets and Apex code into modular packages will be a significant undertaking, and companies need to be sure that the cost is worth the benefit. This is not an all or nothing proposition. The transition to modular packages can take place gradually and should become one of the priorities in your change and release management process. Managed or Unlocked? Second-Generation Packages are deeply integrated with Salesforce DX and have some powerful new features. Under the circumstances, enterprise customers may decide to adopt both technologies. However, there is nothing wrong with using old fashioned unmanaged packages for breaking up an org. Old fashioned managed packages are probably not the right choice, they have special capabilities for ISV deployment on the AppExchange. A major benefit of Second-Generation Managed Packages is that you can have multiple packages with the same namespace. Extension packages can simply use the same namespace, allowing you to easily share Apex code. You can use public Apex classes across packages rather than global Apex classes, which are exposed to everyone. But once a managed package is released, you can’t change some component attributes of its metadata in subsequent versions. Also, Salesforce recommends that you work with a single namespace to avoid complexity managing components. In that case, you can only see the difference between packaged and unpackaged data. You can’t identify individual packages. When you install an ISV product in your org, the unique namespace prevents collision with other assets. But if you are breaking your own org into packages, there are other ways to avoid namespace collisions. Taking all of these considerations into account, breaking an org into unlocked packages is probably the best choice for most companies. When you migrate metadata from your org into a package without a namespace, the API names don’t change. If the API names do change, you will need to remap data records and fix other problems. Adopting unlocked or unmanaged packaging prevents broken dependencies during the transition and gives developers more control over how to organize and distribute the parts of an application. Old fashioned unmanaged packages are being replaced by Second-Generation Unlocked Packages. These packages are integrated with Salesforce DX and can optionally have a namespace. Unlocked packages with a namespace provide a middle ground with some of the advantages of managed packages but more flexibility like an unmanaged package. At some future date we may see Second-Generation Locked Packages as well. These are like the unlocked packages but prevent end user tinkering when deployed. Salesforce DX Salesforce DX is deeply integrated with Second-Generation Packages. You can create package versions, install managed packages, pull source from a Scratch Org, and convert metadata folders into projects. A Salesforce DX project is a file and folder format that defines the source code for a Salesforce org on the local machine. This technology provides source-driven tools for building packages, syncing them with repositories, and deploying them into Scratch Orgs, Sandboxes, and Production accounts. Here’s a thought experiment. Let’s say you break your org up into a bunch of unmanaged or unlocked packages. This is easy to do, just go into the HTML interface and move various assets into unmanaged packages. Without namespaces, most customizations will continue working as before. But how do you know that each package can stand alone, is independent of the other packages, and suitable for continued software development? The only way to do this is to deploy and test each package independently, and this is where Salesforce DX comes in. Each Salesforce DX project can be tested in isolation with a variety of environments. The org:shape:create command can spin up Scratch Orgs with different characteristics, and even mimic your Production org. The source:pull and source:push commands can synchronize the local project with the Scratch Org. The data:tree:import command can populate that org with test data. When the project is working correctly, you can create Second-Generation Packages and Package Versions in your Dev Hub, and these packages can be installed into Developer Editions, Sandboxes, or Production accounts as needed. Mapping Dependencies One extremely useful technique is to retrieve a metadata image of your org and look for connected assets. For example, if you have a Custom Object that belongs to a distinct project then go search the metadata for this object by name and you will probably uncover dozens of other dependencies, including Custom Tabs and Applications, Permission Sets and Profiles, Workflows, other Custom Objects, and Apex Classes. Gather these assets together, and you have an awesome starting point to build a package. When you attempt to create a package, the Metadata API may provide error messages about additional assets that must be included in the deployment. Change Sets will also suggest related assets that are required. Sometimes the dependencies can snowball, demanding more and more of your org for the package to be viable. In this case, you need to look again at how you are factoring the assets and see if some references can be simplified. Package Organization One natural metadata asset to organize each package around is the Custom Application. Each Application will likely have some Custom Tabs and Objects. Starting from there, you will find connected Translations, Workflows, Page Layouts, Apex Classes, and other assets. Lightning Bundles and Apex Pages are also useful starting points to build a package. Second-Generation Packages are often used to organize Apex Classes. This scenario closely matches traditional software development, where source code repositories, continuous integration, and library management are common practices. Apex Class packages can be installed in test orgs and Production environments. They can be organized by function, layer, purpose, namespace, team, or whatever scheme makes the most sense. Public Apex Classes can make calls across packages, so they can all work together. You should be able to explain each package in a single descriptive sentence. The assets in the package should have related names. Unique key words and other naming conventions are a good way to associate the assets, and aids in the metadata search process described above. The goal is a logical package that hangs together and implements a specific project or function. Avoid obsessive code refactoring. A few duplicate scripts can be preferable to lots of entanglements between packages. Converting Packages To divide an org into packages you will need the ability to convert between unpackaged metadata, managed packages, unlocked packages, and Salesforce DX projects. Some of the most useful conversions are listed below, and then discussed individually. Downloading related metadata assets into metadata folders Converting between metadata folders and Salesforce DX projects Converting a managed package into an unmanaged package Downloading related metadata assets in your org into a metadata folder on your desktop is fairly straightforward. To do this, use the Metadata API to retrieve the related assets. Salesforce DX has some commands that simplify downloading metadata. If you want a few packages from your org, or you have the desired assets listed in a Package.xml file, then use mdapi:retrieve command. You can also construct a custom package in a Sandbox with the Salesforce HTML interface and retrieve that the same way. You can turn a metadata folder on your desktop into a package. Change the folder name from “Unpackaged” to the new package name and add the fullName parameter to the Package.xml file. Now those unpackaged assets look just like a downloaded package. You can use the Metadata API to deploy those assets to another org as a package for testing. Converting a metadata folder into a Salesforce DX project and vice versa is also easy. The Salesforce DX command mdapi:convert will translate a metadata folder into a Salesforce DX project. Likewise the command source:convert will translate a Salesforce DX project back into a metadata folder. The Salesforce DX project folder is the right foundation for package testing, deployment, and archive. If you need to make extensive edits to an existing managed package, then converting it to an unmanaged or unlocked package is a handy trick. This technique avoids the editing limitations that managed packages have. The package can be rebuilt with a new namespace after all your edits. As long as other companies or partners are not dependent on the package, an enterprise developer can install the package with a new namespace. Don’t forget that data records may need to be remapped, and that other dependencies on the package namespace can break. To convert a managed package to an unmanaged one, retrieve the managed package with the Metadata API. The retrieved assets will not have a namespace, so they can be deployed as an unmanaged package to a new org. Alternatively, you can grab the reflected assets and strip the namespace prefix. One problem migrating managed packages is that Apex Classes are obfuscated, they have to be refreshed from source. Second-Generation Managed Packages may solve this problem moving forward. The Big Picture Taking a step back to look at the big picture, here are the practical steps for breaking your org into packages, and installing the new packages into Production: Identify related metadata assets that would make good packages Convert these related metadata assets into Salesforce DX Projects Test the Salesforce DX Projects with appropriately configured Scratch Orgs Create Second-Generation Packages and Package Versions in your Dev Hub Install these Packages into Sandboxes for testing or Production for deployment Breaking an org into packages can be done all at once or take place over time as part of your change and release management process. Once everything is organized into packages then future development can continue along with that model. The Production org will be divided into packages that must be individually tested. Salesforce DX is an excellent destination for each package and provides agile tools for testing in Scratch Orgs with different configurations. The flowchart for breaking up your org might look something like this: When you have built Salesforce DX projects that are working correctly, you can create packages in your Dev Hub and then install the packages into Sandboxes for testing or Production for deployment. The Metadata API can be used to deploy other unpackaged assets. You can also use the Metadata API to move Second-Generation Unlocked Packages into Production. This has the advantage of automatic roll-back if there is an error. Be aware, you cannot yet move unlocked packages with the Metadata API if they have a namespace. Hopefully this limitation will be fixed in the future. The diagram below shows an example release flowchart. The Production org is the source in the first diagram, and the destination in the second. Packages are divided out and tested individually. Then they are recombined into Sandboxes and deployed back into Production. The functionality of the org will not be changed, but now the ability to maintain the org and implement new projects has been dramatically improved. Bill Appleton CTO Metazoa

[tak4hir0]

In this post we will talk about Data migration using SalesforceDX. We have a vary simple use case to Import and Export data from one Salesforce Org to another Salesforce Org. We know we can do the same with dataloader or some other custom tool. But in this post we will talk about how to import and export with SalesforceDX (SFDX). If you are new to SalesforceDx please check this ApexHours Session Recording by Jitender Zaa. How to export records with SFDX  Step 1) First Login to your Salesforce Org from where you want to export data sfdx force:auth:web:login --setalias myDev1 Step 2) Use below command to export the data To Export the data we need to use "sfdx force:data:tree:export" command and we need to pass one Soql query. You can also pass the path of SOQL query file with the help of -q. Lets export the Account and its all related contacts records. sfdx force:data:tree:export -q "SELECT Id,Name,(Select FirstName,LastName from Contacts) FROM Account limit 2" -d ./data -p -u myDev1 Here -q : SOQL query or file path of soql query. -d : directory, where exported json file can be saved -u : Salesforce user to perform operation -p : generate multiple sobject tree files and a plan definition file for aggregated import Once you execute above command it will create three file for you in Data Folder. Accounts.jsonContacts.jsonAccount-Contact-plan.json How to Import data using Salesforce DX First login to salesforce org in which you want to import the data. Then use below command to Import records in Salesforce instance, which we just exported in previous step sfdx force:data:tree:import -p data/Account-Contact-plan.json -u myDev1 Where -f : JSON file to be imported -p : plan file -u : Salesforce user to perform operation NOTE: For above use case you don't need any scratch org. You can simply login in any sandbox and migrate your data between two org's. There is another Use case where we can use SalesforceDx for Import and Export Data. Use Case: If you are implementing Continuous Integration (CI/CD) solution built for Salesforce, Some time you need to upload sample data into Salesforce. Solution: For that you need to use command line dataloader or custom tool built to import export data automatically. We can use SalesforceDX for data import and export as well for this requirement. Related Post : Please check this post to learn about SalesforceDx for non-scratch org.Please check this post to learn about VsCode for Salesforce. Further Reading: https://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev_test_data_example.htmhttps://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev_test_data.htmhttps://developer.salesforce.com/docs/atlas.en-us.sfdx_cli_reference.meta/sfdx_cli_reference/cli_reference_force_data.htm Thanks, Amit Chaudhary

[tak4hir0]

And back to the UK, it’s cold here! In brief, I admit I had a blast at Dreamforce this year! It was great to: 1) Showcase HIVE and the teams that I’m doing quite a bit of work with, at the developer keynote. Which had a whole chapter as part of the technology announcements for the year, which I was working with to get it ready with the product and evangelist teams before the event. One of which was Alba Rivas from the dreamOle team that has recently moved on to the Salesforce Evangelist team, it was so nice when I got a whatsapp from her early on in the prep for the keynote Although it really is great to see oneself on the big screen like this I wanted to showcase the team, so I managed to sneak in a little sign. I wonder if Wade thought for a second… oh dear another protester!    2) Laura Walker (who I also work with) opened the Admin keynote, high five-ing Parker Harris on to the stage! And Michael Kolodner, who by the way I had the pleasure to discover is such a gamer! We may be on to something about board games at Dreamforce…   3) Recording the day before Dreamforce a Pluralsight course with Don Robins, Agile for Salesforce coming up in couple months for the #SFPlayByPlay series. It’s a pre #Df19 wrap! Last batch of 2019 #SfPlayByPlay in the can: @Inescapinezka on Agile with #Salesforce and @jan_vdv demystifying #CPQ. Browse all in the PxP gallery https://t.co/xFIYkLxh5J & follow me on @Pluralsight to get notifications https://t.co/ANtDQdrMB9 pic.twitter.com/3uvYV5b5A7 — Don Robins (@donrobins) November 19, 2019   4) Having my crazy cards selling out at the DreamStore. And it’s OFFICIAL: #Dreamforce is going to be epic! My recently released #GAME https://t.co/Tpaf59M8ZY IS @ the #Dreamstore @ #DF19. For #agile teams to selfasses, improve & have fun! Thankyou to make this happen #Agile & #trailblazercommunity. #BNT adventures. I’m over the moon! pic.twitter.com/WAz6hrn1dL — Ines Garcia (@Inescapinezka) November 17, 2019   5) Also sharing some content about Release Readiness, Appexchange and digital nomads, Building applications in the Salesforce platform workshop and a Lightning roundtable. … enough bragging. But seriously it was awesome! Now, I thought to ping some product highlights and share knowledge on what’s coming: Firstly, it was a breath of fresh air during the main keynote to openly acknowledge that one uses more things than just Salesforce. (That statement includes AWS Trailhead modules available now and Amazon Connect as a strategic partnership). Salesforce Economy update is that it keeps growing and growing, so let’s bring people in! So we all can be ready to fill those opportunities with willing, capable and prepared professionals. The little device running Einstein Voice (I think this is Amazon under-the-hood and with connection to Service Cloud, you can build skills to power apps too) made it to the big stage as the announcement of the year, even managed to have a section in every single keynote. The @Salesforce and @AWScloud strategic alliance is expanding to include ways to achieve customer service, learn skills, and make Einstein Voice Builder compatible with @alexa99 and other voice assistants. See everything else announced at #DF19 https://t.co/8rixQcqbYT pic.twitter.com/JO7JQjkg3s — Dreamforce (@Dreamforce) November 25, 2019   Tableau was part of the main keynote, but in my opinion with a very poor showcase and demo. Throughout the conference I had many confused conversations on where does this sit, including from Salesforce Employees. So impatiently watching the space to find out more. More and more on Customer 360 Truth Which connects data from across sales, service, marketing, commerce etc. to create a single, universal Salesforce ID for each customer. Revamp of the Salesforce mobile app, and one of which in my mind must be related to the ‘Trailhead Go‘ a separate app to do modules on the go… ahem this is for questions tick-box not actually doing hands-on exercises. But it’s a starter! There was the announcement that Marketing Cloud will run on Microsoft Azure, so hopefully this will enable other things like: as customer you could find your own logs, be less clunky and have sandboxes? Those are my hopes but not quick ones to deliver. From Marketing Cloud side of things there was another good product release in my mind: the embedded forms within emails I think is pretty cool (maybe an outcome from previous acquisition, I think). Watch the dev keynote! but few quick notes: announcement of Evergreen (serverless functions and elastic compute), Lightning Full sandboxes within minutes!, Data policies and Masking across environments, local development (beta), Open sourcing Lightning base Components… BOOM! Permission set groups another layer for separation of concerns, I think we may need to do some migration from profiles to at least permission set at some point soon. (Conspiracy theory disclaimer: that page layouts will go away) With the announcement of Dynamic Forms for record pages, you can go as granular level of 1 field, that is not only display area but dynamic visibility on user and other value within the record. But is not all ‘happy clappy’, the True to the Core session was good too. It felt to me a bit too short as a big part was to explain the announcement of the IdeaExchange, which is basically a revamp where not all points count the same, so when voting for new features you would do it as ‘a product manager’ with 100 coins to distribute on and how things are important to you. Check it out it’s live already: https://ideas.salesforce.com/s/prioritization There was a really honest session on ‘open conversation of DX’ I leave here a snapshot on what the product team is aware they need to sort out:   On top of all of this, I had some incredible conversations with people, some deep and even some non-Salesforce related (!), certainly quality over quantity. Which with Dreamforce madness this can easily be a challenge. So a big thank you for being part of this Dreamforce to remember! I certainly missed my peeps Chris & Mike throughout, I kept sending them silly stuff… sigh!

[tak4hir0]

ISV Customer Debugger covers a gap in what you can do with Apex Debugger. As an ISV, you can debug your own code. As a subscriber, you can debug your own code. However, because of the protections against seeing managed code, subscribers can’t debug ISV code in their orgs. With ISV Customer Debugger, an ISV can work with a subscriber to debug issues specific to the subscriber’s org. An ISV can reproduce issues in the specific environment, so problems can be diagnosed more quickly. You can debug only sandbox orgs. Configure ISV Customer Debugger ISV Customer Debugger is part of the Apex Interactive Debugger (salesforcedx-vscode-apex-debugger) extension, so you don’t need to install anything other than the Salesforce Extension Pack and its prerequisites. You can debug only sandbox orgs. Log in to your subscriber’s sandbox via your License Management Org (LMO). If you’re not familiar with this process, see the ISVforce Guide. For information on how to obtain login access to your subscriber’s org, see Request Login Access from a Customer. For information on how to log in via the Subscriber Support Console, see Logging In to Subscriber Orgs. In your subscriber’s org, from Setup, enter Apex Debugger in the Quick Find box, then click Apex Debugger. Click Start Partner Debugging Session. In the Using Salesforce Extensions for VS Code section, to copy the forceide:// URL, click Copy to Clipboard. In VS Code, press Ctrl+Shift+P (Windows or Linux) or Cmd+Shift+P (macOS) to open the command palette, then run SFDX: Create and Set Up Project for ISV Debugging. When directed, paste the forceide:// URL into the prompt, and press Enter. When directed, either accept the default project name or enter a name for your debugging project, and press Enter. Choose a location to store the project, and click Create Project. Wait for the project generation process to finish. VS Code retrieves your packaged metadata, your subscriber’s metadata, and skeleton classes for other packages in the org, converts them to source format, and creates a Salesforce DX project. VS Code also creates a launch configuration (launch.json file) for the project. This process can take a long time, especially for orgs that contain lots of metadata, so feel free to leave it running and check back later. You can monitor the progress in the output panel at the bottom of VS Code. To show the output panel, select View Output, then select Salesforce CLI from the dropdown menu in the corner of the Output tab. When the project is ready, VS Code opens it for you in a new window. In the new window, from the Explorer view, open an Apex class or trigger that you want to set breakpoints in. To set a breakpoint, click the gutter to the left of the line numbers. Switch to the Debug view. To launch Apex Debugger, click the play icon next to the launch configuration dropdown menu. Debug Your Subscriber’s Org With one noteworthy exception, debugging a subscriber’s org works the same way that debugging other orgs does. The exception: You can’t break on Apex events triggered by other users in the org. Only the Login As user can trigger Apex breakpoint hit events. See the rest of this README for information about Apex Debugger. For general information about debugging in VS Code, see Debugging in the Visual Studio Code docs. Renew a Debugging Session If your session expires, start a new session from Setup using all the same steps that you followed when you started the original session. Protect Your Subscriber’s Intellectual Property The code from your subscriber’s org is your subscriber’s intellectual property. We advise against keeping it around after you’re done debugging. Delete the entire project from the location where you stored it during the setup process. Never store your subscriber’s metadata in your version control system. When you start a new debugging session later, VS Code downloads the metadata for you again. ISV Customer Debugger Considerations For general Apex Debugger limitations and known issues, see Considerations in the Apex Interactive Debugger article. When working with ISV Customer Debugger, keep these additional considerations in mind. You can debug only sandbox orgs. You can debug only one customer at a time. However, if you purchase Apex Debugger licenses, you can debug multiple customers at once. An Apex Debugger license also lets you debug in your sandboxes and scratch orgs. When you click Return to subscriber overview, your debugging session terminates. Stay logged in to your subscriber’s org while you debug, and return to your LMO only when you’re done debugging. Feedback or Bugs | Edit this Article

[tak4hir0]

Salesforce offers different types of packages (unmanaged, managed and Unlocked). Unlocked packages are especially suited for internal business apps and allowed you to do modular application development. Unlocked package is the right package type for most use cases, Unless you plan to distribute an app on AppExchange. You can use unlocked packages to organize your existing metadata, package an app, extend an app that you’ve purchased from AppExchange, or package new metadata. Unlocked packages help you add, edit, and remove metadata in your org in a trackable way. You can install unlocked package to multiple orgs, and upgrade your Salesforce apps easier and faster. Metadata in unlocked packages can be modified in a production org ( You can do in case of emergency but not recommended). Unlocked packages follow a source-driven development model. The source of truth of the metadata contained within the package is your version control system, not what’s in an org. This model brings with it all the advantages of modern source-driven development models. We did one session on Unlocked Package in ApexHours With Mohith. Here is some highlight of that session. What is Package ? Packaging allows you to group various Salesforce Components (Apps, Tabs, Objects, Layouts, Workflows, Approval Process Flows, visualforce, apex, lightning components, profiles, permission sets and other metadata) for distribution or deployment. A package can also be defined as a container and allows for deployment of the components across various Salesforce organizations. Salesforce Set up UI and Salesforce CLI allows for creation of these. Package Creation yields a URL that allows it to install in various orgs Difference Between Unmanaged package , Manage and Unlocked Package.  Unmanaged Package Managed Package Unlocked Package Not upgradable  Upgradable and has namespace Upgradable and one can namespace them or choose not to Metadata elements are not IP Protected Metadata elements are IP Protected Metadata elements are not locked and can be changed by system admins Can we created in Salesforce UI Can be created in salesforce UI and distributed via appexchange Requires Salesforce CLI to generate them  Unmanaged package containers automatically pull dependency Components are locked and one cannot modify them directly in production or sandbox Allows you to build your applications in a modular way Allows for creation of extension packages Easier to manage when codebase is modularized Modular Application Development Concepts Break Your one monolithic app to multiple packages defining dependency between them. Unlock packages allow you to do them. Building Unlocked packages using Salesforce CLI Please check this recording for step by step process. Thank you so much Mohith for a great session in ApexHours. Here is agenda of session. Introduction To Salesforce PackagingDifferentiate between unmanaged packages , managed packaged and unlocked packagesModular Application Development ConceptsBuilding unlocked packages using salesforce cliCreating Dependency between packagesPublishing and Installing Unlocked packages Here is useful Salesforce DX command to create unlocked package. If you are new to SalesforceDX please check this recording. One can create a package using below   Create a package version as below  Installation can also be done via the Salesforce CLI   By Default a BETA package is generated . We can promote a package using below  References :- https://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev_dev2gp.htmhttps://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev_unlocked_pkg_intro.htmhttps://developer.salesforce.com/blogs/2018/06/working-with-modular-development-and-unlocked-packages-part-1.htmlhttps://www.salesforce.com/video/3599535/