Get the most recent info and news about Salesforce on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Salesforce, Inc. provides customer relationship management technology that brings companies and customers together worldwide. Its Customer 360 platform empowers its customers to work together to deliver connected experiences for their customers. The company's service offerings include Sales to store data, monitor leads and progress, forecast opportunities, gain insights through analytics and relationship intelligence, and deliver quotes, contracts, and invoices; and Service that enables companies to deliver trusted and highly personalized customer service and support at scale. Its service offerings also comprise flexible platform that enables companies of various sizes, locations, and industries to build business apps to bring them closer to their customers with drag-and-drop tools; online learning platform that allows anyone to learn in-demand Salesforce skills; and Slack, a system of engagement. In addition, the company's service offerings include Marketing offering that enables companies to plan, personalize, and optimize one-to-one customer marketing journeys; and Commerce offering, which empowers brands to unify the customer experience across mobile, web, social, and store commerce points. Further, its service offerings comprise Tableau, an end-to-end analytics solution serving various enterprise use cases; and MuleSoft, an integration offering that allows its customers to unlock data across their enterprise. The company provides its service offering for customers in financial services, healthcare and life sciences, manufacturing, and other industries. It also offers professional services; and in-person and online courses to certify its customers and partners on architecting, administering, deploying, and developing its service offerings. The company provides its services through direct sales; and consulting firms, systems integrators, and other partners. Salesforce, Inc. was incorporated in 1999 and is headquartered in San Francisco, California.

Salesforce

salesforce

The two companies, reportedly, couldn’t agree on the terms of the deal.

Salesforce-Informatica acquisition talks fall through: Report | CIO

<strong>Salesforce</strong> (NYSE:CRM) stock rose 0.3% after the business software maker backed away from its talks to acquire data-management software firm Informatica (INFA), down 9%, after the two companies could not agree on terms.

Midday movers: Tesla, Li Auto and CNH Industrial fall; Salesforce rises By Investing.com

:Business software maker <strong>Salesforce</strong> has backed away from its talks to acquire data-management software firm Informatica after the two companies could not agree on terms, a person familiar with the matter told Reuters on Sunday.The talks between the two companies were at an advanced stage earlier ...

Salesforce's talks to buy Informatica fizzle, WSJ reports

You've likely come across WordPress and Salesforce in your professional journey. Perhaps you've even had the chance to directly engage with these platforms. But, have you ever thought about combining the strengths of both through WordPress Salesforce Integration? If not, you're in the right place. Salesforce stands out as one of the most widely embraced Customer Relationship Management (CRM) platforms. It serves as a central hub for companies to streamline their workflows by integrating various applications and services. Its primary goal is to empower enterprises in building robust relationships with their customers. On the flip side, WordPress takes the lead as the go-to Content Management System (CMS) for website creation and hosting. The magic happens when you bring these two powerhouses together. Salesforce WordPress Integration can enhance your marketing workflows and elevate your customers' browsing experience. This integration allows you to seamlessly connect your WordPress forms with Salesforce, enabling your team to automatically add leads, customers, and other contacts to your CRM. In the following discussion, we'll delve into the world of WordPress and Salesforce integration. As we progress, you'll gain insights into the steps involved in setting up Salesforce WordPress Integration. Let's explore the synergies between these platforms and unlock new possibilities for your business. What is Salesforce to WordPress Integration Salesforce to WordPress Integration is the strategic alignment of Salesforce, a prominent Customer Relationship Management (CRM) platform, with WordPress, a leading Content Management System (CMS). This integration seamlessly connects the robust CRM functionalities of Salesforce with the dynamic content management capabilities of WordPress. It enables businesses to synchronize and leverage customer data, ensuring real-time updates on their websites. By automating the transfer of data between Salesforce and WordPress, manual data entry is eliminated, saving time and reducing errors. This integration not only centralizes customer information but also facilitates personalized content delivery, enhancing marketing efforts and fostering a more engaging user experience on WordPress-powered sites. It represents a powerful synergy between CRM and web presence, optimizing overall digital strategies for businesses. Benefits of Salesforce to WordPress Integration 1. Enhanced Marketing Efficiency: Salesforce to WordPress Integration empowers businesses to leverage the robust CRM data from Salesforce in crafting personalized and targeted content on their WordPress websites. The seamless connection allows for real-time updates, ensuring that marketing strategies are based on the latest customer interactions and preferences. 2. Streamlined Lead Management: This integration facilitates the smooth capture of leads from WordPress websites, directing them seamlessly into the Salesforce CRM system. By consolidating lead data in a centralized system, businesses can adopt a unified approach to lead nurturing, tracking, and conversion. 3. Data Consistency and Accuracy: Automatic synchronization between Salesforce and WordPress significantly reduces the risk of discrepancies or outdated information. The integration promotes data accuracy, providing reliable, real-time insights that enhance decision-making processes for strategic planning and execution. 4. Efficient Workflow Automation: Salesforce to WordPress Integration automates data transfer processes, eliminating the need for manual entry and saving valuable time for marketing and sales teams. Triggering workflows in Salesforce based on user interactions on WordPress ensures timely and relevant responses to customer actions. 5. Improved Customer Engagement: The integration fosters a cohesive approach to customer relationship management by seamlessly connecting CRM insights with online interactions on WordPress. Personalized content delivery enhances the overall user experience, strengthening connections with site visitors and potential customers. 6. Optimized Data Utilization: Unifying customer data from both platforms allows businesses to leverage a comprehensive view of customer interactions and behaviors. This optimization of CRM data enhances marketing strategies and facilitates a deeper understanding of customer preferences. 7. Cost and Time Savings: Reduction in manual data entry minimizes the likelihood of errors, resulting in cost savings by eliminating the need for extensive data correction efforts. Automation of processes streamlines operations, freeing up time for teams to focus on strategic initiatives and high-impact tasks. 8. Scalability and Flexibility: Salesforce to WordPress Integration provides a scalable solution that can evolve with the growing needs of businesses. This flexibility accommodates changes in marketing strategies, ensuring the integration remains effective as the customer base expands and data volumes increase. A Step-by-Step Manual for Integrating Salesforce with WordPress If you're eager to blend the power of Salesforce with the versatility of WordPress, here's a straightforward guide to kickstart the process: Prepare Your Salesforce Account: Begin by ensuring your Salesforce account is ready for integration. Create a custom object to house your WordPress leads and establish a web-to-lead form for efficiently gathering data from your WordPress website. Install Essential WordPress Plugins: To seamlessly integrate Salesforce with WordPress, install essential WordPress plugins. Options like Salesforce WP-to-Lead, Gravity Forms, Salesforce Add-on, and Salesforce Anywhere are popular choices. These plugins come with pre-built features, easily customizable to suit your specific business requirements. Connect Salesforce to WordPress: After installing the necessary plugins, link up Salesforce with your WordPress platform. Typically, this involves inputting your Salesforce API credentials into the WordPress plugin settings. Some plugins might need additional configuration for optimal functionality. Configure Integration Settings: With Salesforce connected to WordPress, tailor the integration settings to your needs. This might involve mapping WordPress fields to Salesforce fields, establishing lead assignment rules, and configuring other integration preferences. Most of these adjustments can be made within the WordPress plugin settings. Test the Integration: Once the integration settings are in place, conduct thorough testing to confirm its proper functioning. Submit a test lead from your WordPress website and verify that it seamlessly syncs with your Salesforce account. Additionally, test other integration features like marketing automation and lead nurturing to ensure their smooth operation. By following these steps, you'll successfully merge Salesforce with WordPress, streamlining your lead management and marketing automation processes. Keep in mind the importance of regular monitoring, making necessary updates or configurations to adapt to the evolving needs of your business. This integration can be a game-changer, enhancing your ability to manage leads efficiently and automate key marketing tasks. Best Practices for Salesforce to WordPress Integration By adhering to these best practices, you can navigate the Salesforce to WordPress integration process effectively, fostering a streamlined, secure, and efficient connection between these two powerful platforms. Clearly Define Integration Objectives Begin by outlining specific integration goals. Clearly define what data needs to be synced between Salesforce and WordPress and how it aligns with your overall business objectives. Choose Reliable Integration Tools Select reputable and well-supported integration tools or plugins that cater to Salesforce to WordPress Integration. Ensure they are reliable, secure, and compatible with the versions of both platforms. Thoroughly Plan Data Mapping Invest time in mapping data fields between Salesforce and WordPress. This meticulous planning ensures seamless data flow, preventing discrepancies and data inaccuracies during integration. Implement Real-Time Synchronization Enable real-time synchronization to keep data consistently updated across Salesforce and WordPress. This helps maintain accuracy and ensures that both platforms operate with the latest information. Regularly Test Integration: Conduct thorough testing during and after the integration process. Test various scenarios, including lead submissions and data updates, to verify the integration's functionality and identify and address any potential issues. Optimize Workflow Automation: Leverage workflow automation capabilities to streamline processes. Set up automation for routine tasks, such as lead assignment and follow-ups, to enhance efficiency and reduce manual intervention. Prioritize Data Security and Permissions: Implement robust security measures to safeguard sensitive data during integration. Configure user permissions meticulously, ensuring that only authorized personnel have access to specific information. Provide Training for Users: Train your team on using the integrated system effectively. This includes understanding how to navigate the integrated Salesforce features, input data, and utilize the enhanced capabilities for better Salesforce development productivity. Monitor Performance Metrics: Establish key performance indicators (KPIs) for the integration and regularly monitor them. This practice helps you gauge the impact on workflow, identify areas for improvement, and ensure the integration aligns with business objectives. Document and Maintain: Maintain comprehensive documentation of the Salesforce customizations made, integration setup, and configurations. Regularly update this documentation to ensure clarity for future maintenance and troubleshooting. Conclusion If you're thinking about connecting Salesforce with WordPress, invest time in finding the best integration method. Plan your integration strategy meticulously and consider teaming up with a reliable Salesforce integration Partner if needed. By adopting the right approach and following best practices, integrating Salesforce with WordPress has the potential to elevate your business to new heights.

How to Integrate WordPress with Salesforce

সেলসফোর্সের সাথে কীভাবে ওয়ার্ডপ্রেসকে একীভূত করবেন

So integrieren Sie WordPress mit Salesforce

Cómo integrar WordPress con Salesforce

Comment intégrer WordPress à Salesforce

सेल्सफोर्स के साथ वर्डप्रेस को कैसे एकीकृत करें

WordPress と Salesforce を統合する方法

Salesforce와 WordPress를 통합하는 방법

Como integrar WordPress com Salesforce

Как интегрировать WordPress с Salesforce

WordPress'i Salesforce ile Entegre Etme

Cách tích hợp WordPress với Salesforce

如何将 WordPress 与 Salesforce 集成

Are you struggling to keep track of all the changes happening in your Salesforce data over time? Look no further, as we introduce an easy and efficient way to create reporting snapshots in Salesforce. Say goodbye to the hassle of manually tracking changes and hello to a more streamlined and effective process. Key Takeaways: Efficiently track changes over time in your Salesforce instance with reporting snapshots Create historical reports for better analysis and decision-making Follow best practices such as defining a clear purpose and regularly reviewing and updating snapshots for optimal use Alternative approaches might make sense, depending on your requirements or limitations What Is Salesforce Reporting Snapshot? A is a powerful tool that enables users to capture tabular data at a specific point in time, providing valuable insights into changes and trends over time. This feature is particularly useful for creating historical reports and allows organizations to easily compare data from different periods. Salesforce Reporting Snapshot By utilizing Salesforce Reporting Snapshot, users can analyze the evolution of their data and make informed decisions based on historical information. How Can Salesforce Reporting Snapshots Help Your Business? Salesforce reporting snapshots are a powerful tool that can provide valuable insights for your business; namely how opportunities, accounts and business evolves over time. In this section, we will explore the different ways in which the reporting snapshot functionality can help your business. First, we will discuss how it allows you to track changes over time, such as opportunity pipeline changes and revenue per rep, for future reference. Then, we will look at how it can be used to create historical reports. For example, a common historical report use case is to look back at the number of leads in the last 7 days, or the total pipeline by stage at the start of the month or quarter. Finally, we will walk through how a reporting snapshot can help compare data across different time periods, making it a valuable data analytics tool for any Salesforce organization. 1. Tracking Changes Over Time A sales team might use Salesforce reporting snapshots to monitor changes in their opportunity pipeline over a year, revealing fluctuations in deal sizes and win rates, leading to strategic adjustments. Analyze the data to be tracked over time and identify the specific fields and objects to include. Create a report in Salesforce to capture the required data, ensuring it's structured for future reference. Schedule the reporting snapshot to run at regular intervals, capturing changes in opportunity pipeline, case object volume per rep, and API calls trending. 2. Creating Historical Reports Teams track the number of leads through historical reports so they can adapt their strategies to the fluctuating number of prospectors over time. Create a new report or open an existing report in Salesforce. Set the report filters to specify the historical data range, for example, 'last 7 days'. Include the relevant fields such as 'number of leads' and any additional criteria for the historical report. Run the report to generate the report on the number of leads based on the defined parameters. Save the report for future reference and analysis. 3. Comparing Data Across Different Time Periods When utilizing Salesforce Reporting Snapshots, Salesforce orgs can effectively compare data across different time periods, offering valuable insights into changes over time. This data analytics tool enables users to track and analyze changes, facilitating informed decision-making and strategic planning. How To Set Up Salesforce Reporting Snapshots? Setting up Salesforce reporting snapshots is a great way to track changes over time in your organization. This can be especially useful for small businesses or organizations that may not have a dedicated data analyst. In this section, we will walk through the steps of setting up a reporting snapshot for a custom object, including defining the data to be captured, creating a report to capture the data, and scheduling the snapshot to run regularly. By the end, you will have a clear understanding of how to set up this valuable tool for your organization. Note: you’ll need to create custom objects to enable Reporting Snapshots. Don’t have these permissions or want to avoid custom objects? Jump ahead to see alternative approaches. 1. Define the Data to be Captured Define the specific data that you want to capture, including custom fields and text area fields. Pro-tip: When setting up Salesforce Reporting Snapshot for a small organization, ensure that the custom object and text values are aligned with the reporting needs, enabling comprehensive data capture. 2. Create a Report to Capture the Data Create a custom object to store the historical data, including a unique reference ID value for each single record to ensure proper tracking. Set up a report folder to efficiently organize all reports. Establish unique reference id values for each record to ensure proper tracking. Create a report to capture the required data from the custom object. For seamless data capture, make sure the custom object is configured to hold all necessary fields and relationships. Regularly update the report to include any new data and use filters to refine the captured information. 3. Schedule the Reporting Snapshot Define the data to be captured in the snapshot records. Create a report to capture the data required for the snapshot. Schedule the reporting snapshot to run at specific intervals for automated updates. Setting up opportunity pipeline reporting snapshots can allow reports and searches on through a custom tab. related objects Best Practices for Using Salesforce Reporting Snapshots When it comes to effectively utilizing Salesforce reporting snapshots, there are several best practices that can make a significant difference in the accuracy and usefulness of the data. In this section, we will discuss the top three best practices for using Salesforce reporting snapshots. From defining a clear purpose for the snapshot to regularly reviewing and updating it, these tips will help you make the most out of this powerful tool. Additionally, we will explore the benefits of using filters and filters in the report to further enhance the accuracy and relevance of your data. 1. Define a Clear Purpose for the Snapshot Identify the specific business objectives and goals that the Salesforce Reporting Snapshot will address. Clarify the intended audience for the Salesforce Reporting Snapshot reports to ensure relevance and usefulness. Define the key performance indicators (KPIs) and metrics that will be captured in the Salesforce Reporting Snapshot for effective monitoring. Create a plan for how the Salesforce Reporting Snapshot data will be utilized to drive decision-making and strategic initiatives. 2. Regularly Review and Update the Snapshot Establish a consistent schedule for reviewing the snapshot, to ensure timely updates. Confirm the accuracy and relevance of the captured data during each review. Revise the snapshot with the most recent information and make any necessary adjustments based on changing requirements. 3. Use Filters and Filters in the Report Utilize various filter options in the report to refine and customize the data according to specific criteria. Apply Filters: Combine multiple filters to create complex logic for precise data segmentation and analysis. Filter Logic: Implement report filters to narrow down the data displayed in the report results. Report Filters: What Are the Alternatives to Salesforce Reporting Snapshots? While Salesforce Reporting Snapshots are a useful tool for tracking changes over time, it is not the only option available. In fact, there are several alternatives that may better suit your reporting needs. In this section, we will discuss the different alternatives to Salesforce Reporting Snapshots, including the use of custom reports, third-party reporting tools, and manual data tracking. Each alternative offers its own unique features and benefits, and we will explore how they compare to Salesforce Reporting Snapshots. 1. Custom Reports Determine the specific data requirements and the insights you aim to gain from the custom report. Identify Data Needs: Structure the report to showcase the data effectively, ensuring it aligns with the intended analysis. Design Report Layout: Apply relevant filters to refine the data presented, enhancing the report's precision. Configure Filters: Incorporate custom fields to tailor the report to your unique business metrics and KPIs. Utilize Custom Fields: Consider leveraging custom reports to extract tailored insights aligned with your business objectives, fostering informed decision-making and strategic planning. 2. Third-Party Reporting Tools There are many third party reporting tools for Salesforce, but when it comes to history tracking, flexible spreadsheet-oriented solutions work best. Salesforce’s , Coefficient’s for Salesforce, or offers an easy and highly customizable solution. Google Sheets connector Google Sheets connector Gigasheet’s Salesforce reports snapshot option Research and Identify: Explore various third-party reporting tools available in the market. Assess Compatibility: Evaluate the compatibility of each reporting tool with your existing systems and data sources. Compare Features: Analyze the features and functionalities offered by different third-party reporting tools to determine the best fit for your business needs. Cost Analysis: Consider the cost implications, including initial setup, licensing, and ongoing maintenance, when choosing a third-party reporting tool. Implementation Process: Plan the implementation process, including data migration and user training, for the selected third-party reporting tool. 3. Manual Data Tracking Identify the specific data points that need to be tracked manually, such as sales figures, customer interactions, or inventory levels. Create a structured system for recording the data, whether it be through spreadsheets, physical logs, or dedicated software. Establish a regular schedule for data entry and ensure consistency in the manual data tracking process. Note: the third-party software listed above can be scheduled to assist with manual data tracking. FAQs About Salesforce Reporting Snapshots What is Salesforce Reporting Snapshots and how can it help me track changes over time? Salesforce Reporting Snapshots is a built-in feature in Salesforce that allows you to take a "picture" of a set of records and freeze the data on them for future reference. This can be especially useful for tracking changes over time, such as Opportunity Pipeline growth. Can I use Salesforce Reporting Snapshots for other types of data besides Opportunity Pipeline? Yes, you can use Reporting Snapshots to capture other types of data such as Case object volume-per-rep, API Calls trending, or the number of Leads owned by users. Are there any limitations to using Salesforce Reporting Snapshots? One limitation is that you can only capture up to 2,000 records at once. If you have a small org or less than 2,000 records, this should not be an issue. Additionally, the running user for the Snapshot must always be active or the Snapshot will not run. Alternatives like manually exporting custom reports, manual data tracking, or alternative solutions allow you to get around these limitations. Salesforce History Tracking How do I set up Opportunity Pipeline Reporting Snapshots? To set up Opportunity Pipeline Reporting Snapshots, you will need to create a report folder and report, to create a custom object to hold the results, set up the snapshot, schedule the snapshot, and then report on the results. This process is outlined in detail in the reference data above. What If I Can’t Create Custom Objects? If you don’t have access to create custom objects, consider one of the alternatives listed above. Can I set up a recurring schedule for my Salesforce Reporting Snapshots? Yes, you can set up a recurring schedule for your reporting snapshots, which will run according to the frequency you choose (e.g. daily, weekly, monthly). You can also choose to receive an email when the snapshot runs. The alternative third-party tools listed above also allow for scheduling as well. Can I report on the results of my Salesforce Reporting Snapshots? Yes, you can generate a report for the custom object you created to hold the results of the Reporting Snapshot. This report can be set up like any other Salesforce report, with options to group by date, stage, or other filters as needed.

How to Set Up and Use Reporting Snapshots In Salesforce To Track Customer History

101 Stories To Learn About Salesforce

An In-Depth Guide to Salesforce Integration

Una guía detallada para la integración de Salesforce

Un guide détaillé sur l'intégration de Salesforce

सेल्सफोर्स एकीकरण के लिए एक गहन मार्गदर्शिका

Salesforce 統合の詳細ガイド

Um guia detalhado para integração com Salesforce

Hướng dẫn chuyên sâu về tích hợp Salesforce

Salesforce 集成深入指南

A Salesforce Jira integration boosts productivity and gives users the ability to track valuable performance metrics on a day-to-day basis. When you connect Jira to Salesforce, you can analyze and use data faster as a way to solve user-related problems before they escalate. Why integrate Jira and Salesforce? is the go-to tool for the majority of teams, and its Salesforce CRM is one of the most popular customer relationship management tools.  The two are comprised of a variety of different modules that answer each individual need of the enterprise. Jira DevOps A Salesforce Jira integration (preferably, a bi-directional one) significantly enhances the overall teams’ performance, eliminates errors that come from manual work, and removes silos. Improved cross-team collaboration, bug tracking, and easier project management. Faster request resolution, critical for both Jira and Salesforce IT teams Simplified problem management and elevated customer experience Elimination of manual work, leading to minimizing costly errors or faulty data Improved operational efficiency by automating the Jira Salesforce workflows and full control over critical business information With a successful Jira Salesforce integration, downtimes and service interruptions are reduced. The support team’s on-time reaction makes it possible. When a Salesforce Jira integration is in place, simplified customer interactions lead to high levels of customer satisfaction. You can see more details about the reasons for a Salesforce Jira integration in our article “ ”. Why integrate Salesforce and Jira How to choose your Jira Salesforce integration solution? A Jira Salesforce integration can be seamless if you opt for the right integration tool. However, this is not always an easy task. While there are plenty of integration tools on the market, they usually miss some of the critical requirements for flawless Salesforce Jira integration. What to consider when looking for a Salesforce Jira integration tool – if you need to make your Salesforce Jira integration quickly, don’t want to waste time on a steep learning curve, or have no spare engineers for coding the integration, you need to consider a no-code platform. With a no-code platform, on the other hand, you can have your Salesforce Jira integration set up very swiftly and you need no specialists on your side to work on it. No-code vs low-code – If your Jira Salesforce integration is not scalable, it will be quite difficult to maintain it, as in most cases the situation changes quickly. Scalability – in the ideal case you will be protected in events of downtime, your data will be completely secure, and your integration tool will stick to the highest security standards. Security and Reliability About ZigiOps’ no-code integration platform ZigiOps establishes the Salesforce Jira integration in a few clicks. It provides numerous benefits -instant bi-directional connection, easy data transfer, no-code setup, pre-built integration templates, real-time updates, full customization to fit even the most complex Jira Salesforce integration use case, and more. ZigiOps' key features make it easy even for a non-technical person to configure a fully functional Jira Salesforce integration. This is why we choose it for the current guide. Jira Salesforce integration use case One of the most common examples regarding the Jira Salesforce integration is transferring the Salesforce case to the Jira issue. The tech team notices a newly created case in Salesforce, and it is related to a development project, so they want it to show up in Jira, too. ZigiOps automatically identifies the Salesforce case, transfers it to Jira, and instantly creates a related issue. Any updates sync immediately. Valuable data such as regular, custom, and lifecycle fields, comments, and attachments are also automatically synchronized. Initial setup of the Jira Salesforce Integration The first step is to .  It can be either installed on your premises, VM or you can leverage the AWS version of the platform.  For the latter, you can directly log in through the iPaaS portal. install ZigiOps Once logged in, you get a complete view of the ZigiOps’ Dashboard that shows information on the health status of the integrations, licenses, number of transactions between systems, and other data. Connecting to Salesforce From the “Connected Systems” menu, located on the left sidebar, we must choose the systems we want to integrate. In our case, they are Jira and Salesforce. Let’s start with Salesforce. ZigiOps uses APIs to connect with the systems. To initiate the connection with the Salesforce instance to ZigiOps, you need the following details: The Salesforce instance URL Username Password Client ID Client Secret Please note that to connect, you need to have an administrator account in Salesforce, or an account with “Modify All Data” permission. After filling in these fields, ZigiOps will automatically check the connection and let you know it’s successful. In the background, the integration platform collects detailed Salesforce data (metadata and schema details), so it can load all available fields and use them for establishing the Jira Salesforce bi-directional integration later. This makes configuring the Jira Salesforce integration very easy and straightforward. Connecting to Jira When Salesforce is added, we also need to connect our Jira instance, which in this case will be our destination system. The process is quite similar – you need to choose Jira from the available systems for integration and then enter the following details: Instance URL Username Password In case you are using Jira Cloud, you will need a Username and API token (instead of a password). If you’d like, you can also login through a proxy. You need to have the following permissions for your Jira account: Add Comments Assign issues Browse Projects Create Attachments Create Issues Edit Issues Resolve Issues Transition issues Jira Salesforce Integration Templates Once you have successfully connected your systems to ZigiOps, you can start configuring your Jira Salesforce integration. ZigiOps comes with pre-defined templates that you can load with a couple of clicks. They cover the most common use cases for our Jira Salesforce integration, but you can also customize them completely, so they can fit any integration use case that you have. You can also import your own integration templates or start from scratch if you prefer. For this Salesforce Jira integration guide, we will use the out-of-the-box transfer of Salesforce Cases to the Jira Tasks template. You can load it when you go to the “Configurator” menu and click on the “Add New Integration” button. There you will see all the templates that are available in ZigiOps, and you can easily search for the one you need. When you find the Salesforce Cases to Jira Tasks template, you just need to click on it, and you will be able to load it right away. Jira Salesforce Integration Configuration Once you load the Jira Salesforce integration template, you will see the integration appear in the left column in ZigiOps. You can click on it, in order to be able to configure it. The template will automatically set Salesforce as the target system (or system 1), and Jira as the destination system (or system 2). You can change that anytime. You will also have the entity fields automatically populated as Cases for Salesforce and Tasks for Jira. However, when you click on them, you will see all available entities (salesforce entities) that you can easily customize and set to be connected. This is because ZigiOps automatically loads the schema for the systems and makes it super easy for you to set the logic for your integration. It is the same for both Jira- Salesforce integrated systems. For each integration configuration in ZigiOps we have the “Correlation” menu. It provides access to the fields from both systems that are part of the data synchronization, and you can sync additional fields if you’d like to. It is also used to set bi-directional updates and control the correlation logic between the objects in the two systems. ZigiOps’ Correlation is configured separately for each integration flow. On the Salesforce part, the correlation fields are: transactions (Transaction) customfield_10001 (Team) created (Created) reporter (Reporter) priority (Priority) fixversions (Fix versions) key (key) and more. In this way, every integration can have different logic and rules for how relationships and data updates will be performed. After the initial relationship is established if something changes to any of the integrated entities this change will be synchronized with the related entity in the other system. Salesforce Jira integration action items For each integration, we can have an unlimited number of actions that we can add. In our case we have three actions: The initial creation of the Jira task every time there is a new Salesforce case that needs to be transferred Updating the Salesforce Case when new changes in the corresponding Jira Task are present Updating the Jira Task when there are changes in the corresponding Salesforce Case Each action has easy-to-navigate options and settings we can adjust the way we need to. The first of the three actions – the initial creation of the Jira Task based on a corresponding Salesforce Case – provides us with the trigger and trigger condition settings. When we click on the “Create Task” action item, we can define the type of trigger we would like to use. For this example, we will use “polling” which means ZigiOps will check for new cases in Salesforce on a pre-defined interval. You can set the interval to hours, minutes, or seconds, as well as days or weeks, if you do not need more frequent updates. The trigger conditions can be defined by using different expressions that provide a lot of freedom about what you can do with the integration. You can create expressions, based on: Pattern Extract from Array Build Array To Lower Case To Upper Case First n Characters Last n Characters Replace Text Date and Time Format Last Time The Last Time expression is the most often used one. In this case, we use it to filter the Cases that we have already transferred to Jira and collect only the new ones. ZigiOps will transfer only the Salesforce cases that are created after the last transfer to avoid duplicate Salesforce records. Jira Task Mapping At the time a new Jira Task is initially created based on a Salesforce Case, ZigiOps provides us with the option to map all available fields the way we want to. We have the “summary”, “description” and “priority” fields already mapped in the template, but we can add mapping conditions for any other field that we have in Jira: transitions (Transitions) customefield_10001 (Team) created (Created) reporter (Reporter) priority (Priority) fixversions (Fix versions) parent (Parent) You can also easily change the mapping conditions or add new ones. Update Salesforce Case The next step in the bi-directional Jira Salesforce integration is to set the conditions when ZigiOps will check for updates in Jira and transfer them back to Salesforce. As our Jira Salesforce integration is bi-directional, any changes and updates can be synchronized. Again, we can set the trigger that specifies when ZigiOps will be looking for updates and transferring them back from Jira to Salesforce. We are using polling once again. If we set it to 1 minute, ZigiOps will be checking for updates every minute. In our example, we are using the to check for the latest comments, logs, attachments, or other changes, that have not yet been transferred. This way we make sure that we do not transfer duplicate records anywhere. Last Time expression Update Jira Task When we click on the “Update Task” action, we will see the settings for the Jira task updates. They are identical to the Salesforce Case updates. We can again set the trigger type, and trigger conditions, and define different expressions that we can use to customize the integration the way we want to. Expl. Our trigger conditions’ fields in the Jira Salesforce integration can be the following: lastmodifieddate lastmodifiedby/username createdby/username This completes our Salesforce Jira Software integration. We can click on the “Save” button in the upper right corner, and our integration will be activated. ZigiOps vs Internal Integrations for a Salesforce Jira Integration There are a lot of factors to consider when deciding on an integrated approach. Many times, companies would choose to develop their own solutions only to find out that it is much more expensive, takes more time, and requires more resources than a ready-made integration tool. Integrations tend to change and scale with time – requirements may change, you might need to integrate additional fields or entities, new versions of the integrated tools appear, your business grows, etc. Internal solutions would not only need to dedicate resources to launch it but to maintain and scale it when necessary. This is usually quite costly and takes a lot of man-hours of work. . With it you can set your integrations within minutes instead of months, it is easily scalable, and you can make changes and updates in your integrations anytime. Another great advantage is that ZigiOps supports high availability, protects you in cases of downtime, and always supports the latest versions of the tools you are integrating. . All of the above can be avoided when using a stand-alone integration platform like ZigiOps We maintain the highest security standards and are ISO27001 certified Questions to ask when looking for the best integration platform There are plenty of tools on the market that execute Salesforce Jira integration. However, they often have important components missing. Here are a few questions to ask yourself: Does it meet all of the requirements for your use case – can the integration tool handle complex data dependencies and custom fields, does it have easy customizations of the field mapping and filtering? ZigiOps provides options for customizing your integrations and capturing all types of fields and dependencies just through the UI. You can adjust and customize it in a few clicks. Complexity and coding skills – does the integration tool require a developer to work on the integration? If you are going to need an expert or a whole team working with the tool, how much time and resources would that take? ZigiOps is completely no-code and, with the out-of-the-box templates it provides, you can literally set your integration within minutes and activate it. Scalability – if your requirements change or you need to make additions to your integrations, would the chosen integration tool support that? Would it require additional licensing and how much would it cost you to make changes? With ZigiOps you can easily scale, and you can make changes to the integration whenever you wish. There is no limitation on the number of fields and entities you transfer between Salesforce and Jira. Reliability – is the integration tool secure and reliable? In case of downtimes and problems with the integrated systems, how would that affect your integrations? With ZigiOps you are protected, as it offers high availability and follows the highest security standards (none of your data is stored by the tool). Customer support – does the integration tool have fast and reliable support in case you need it? ZigiOps has world-class support ready to answer all of your questions and go the extra mile to assist you with your integrations. Data analytics - is the accumulated amount of data containing all the necessary metrics? Can it share data properly between the company's departments? ZigiOps makes sure both Jira development and Salesforce teams have full access to the entire amount of details aggregated from the two systems. Also, ZigiOps helps both teams (Jira and Salesforce) maintain control over the entire customer life cycle and software development process so that customer issues are resolved faster. Conclusion A no-code, bi-directional Salesforce Jira integration provides tech, marketing, and sales teams with the ability to automate data transfer and eliminate silos. It brings lots of benefits like faster issue tracking and resolution, boosted business productivity, and improved teamwork. While other platforms often require additional lines of code, the ZigiOps connector does not. If you are planning a Jira Salesforce integration, to see how ZigiOps can easily solve your integration dilemmas. get in touch with us and book a demo You can also check out ZigiOps’ Salesforce Jira integration solution at the Atlassian marketplace or simply visit our Jira Salesforce integration page for further technical details.

Boost Productivity with a Bidirectional Salesforce Jira Integration

Aumente la productividad con una integración bidireccional de Salesforce Jira

Augmentez la productivité avec une intégration Salesforce Jira bidirectionnelle

एक द्विदिश Salesforce जीरा एकीकरण के साथ उत्पादकता बढ़ाएँ

双方向の Salesforce Jira インテグレーションで生産性を向上

Aumente a produtividade com uma integração bidirecional do Salesforce Jira

Tăng năng suất với Tích hợp Jira Salesforce hai chiều

通过双向 Salesforce Jira 集成提高工作效率

Part One: SOAP-based APIs Simple Object Access Protocol (SOAP) is a messaging protocol based on requests and responses using an XML format. Although some legacy systems still use SOAP over SMTP, the transport method typically used for SOAP requests is HTTP. As an API protocol, SOAP is platform- and language-agnostic, allowing for two applications running on completely different systems to communicate with one another. This post is part of a two-part series covering how to create custom API endpoints in Salesforce with APEX. In Part One, we’ll walk through how to create a SOAP-based API endpoint for other applications to use when communicating with your Salesforce org. A Brief Introduction to SOAP Each SOAP message is contained in an “envelope,” which has a header and a body. The header contains application-related information, such as the date when the message was generated or ids related to the message context. The body contains the actual message. Here is an example SOAP message with a format that would be used for authenticating to Salesforce: <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:urn="urn:enterprise.soap.sforce.com">
   <soapenv:Header>
      <urn:LoginScopeHeader>
         <urn:organizationId>12345</urn:organizationId>
         <urn:portalId>abcde</urn:portalId>
      </urn:LoginScopeHeader>
   </soapenv:Header>
   <soapenv:Body>
      <urn:login>
         <urn:username>johndoe</urn:username>
         <urn:password>mypassword</urn:password>
      </urn:login>
   </soapenv:Body>
</soapenv:Envelope> Since each message has the same structure, SOAP is system agnostic. For example, an application running on a Windows 11 machine can send a message to another application running on a Unix-based web server. Though the message can be sent using SMTP or HTTP, SOAP messages should ideally be sent with HTTPS, with either simple or mutual authentication. SOAP is mostly used to create an or to exchange server-to-server information. Therefore, it is very important for the two systems to establish trust. Salesforce provides multiple ways to accomplish authentication. API web service The relationship between SOAP and WSDL Although all SOAP messages have the same structure, the SOAP specification doesn’t define other aspects, such as message format or transport protocol. The Web Services Description Language (WSDL) describes the message formats, transport details, and operations of the web service. The WSDL file can be considered a contract between the client and the service. How to Create a SOAP-based API in Salesforce Now that we have covered the fundamentals let’s begin implementing our SOAP API. Set up a Salesforce org First, you need a Salesforce org. Salesforce provides free Developer edition orgs, and signing up for one is straightforward. Go to the and provide your details. You should receive an invite link within a few minutes. sign-up page Creating a global class with Apex To create a SOAP web service in Salesforce, we will need to create a globally defined Apex custom class. In our class, we’ll use the keyword and definition modifier for every method we want to expose. Adding the keyword automatically gives global access to the method it is added to. webservice static webservice In order to create this class in our shiny, new org, we go to , and then find . In the table listing existing classes, we click . Setup Custom Code -> Apex Classes New To learn more about Apex and how to create classes, check out this and the . Trailhead page Apex documentation Below, we have a sample class that exposes a method used to create new Contact records in Salesforce. The method accepts a Contact’s details as parameters and inserts a new Contact record. ContactAPI createContact If successful, it returns the ID of the newly created Contact along with a message. In case of a failure, it returns an error message. Please copy the code and paste it into the newly created empty class. global class ContactAPI {
  webservice static String createContact (String firstName, String lastName, String contactEmail, String salutation) { 
    try {
      Contact newContact = new Contact();
      newContact.Salutation = salutation;
      newContact.FirstName = firstName;
      newContact.LastName = lastName;
      newContact.Email = contactEmail;

      insert newContact;
      return 'Successfully inserted new Contact! Id:' + String.valueOf(newContact.Id);
    } catch (Exception e) {
      return 'Error:' + e.getMessage();
    }
  }
} Next, we click . Save That’s it! Our web service is ready for operations. We have successfully created a SOAP API in Salesforce. Generate the WSDL We now need to generate a WSDL file and provide it to the external application or third-party developers who can then consume it to call our method. createContact Salesforce provides two out-of-the-box WSDL files to integrate client applications with Salesforce: The is optimized for a single Salesforce org. It’s strongly typed, meaning it contains objects and field definitions for this particular org. Whenever there is a change in the metadata (object and/or fields) in the Salesforce org, a new WSDL needs to be generated and provided to the client (to consume again). Enterprise WSDL The is optimized for use with many Salesforce orgs. It’s loosely typed, and it doesn’t change based on an org’s specific configuration. Partner WSDL In order to utilize our web service, we’ll use the WSDL for our Apex class (to actually call our web service), and we’ll use the Enterprise WSDL to authenticate to Salesforce. After creating our class, we see it show up in the list of Apex classes. In the row for ContactAPI, we click on the link to generate a WSDL. ContactAPI WSDL This will open a new tab with our WSDL, which will look similar to this: We save this file to our local machine, naming it . contactAPI-wsdl.xml To generate the Enterprise WSDL for our Salesforce org, we go to the Setup page, and then find . Then, we click on . Integrations -> API Generate Enterprise WSDL Your generated WSDL should look similar to this: We save this file to our local machine, naming it . enterprise_wsdl.xml To generate the WSDL for your Apex Class: Go to the Setup page. Type and select Apex Classes. Find your class. In our case, it’s ContactAPI. Click on the name. On the next screen, you will have the class page where you have the button. Generate WSDL Test and validate To ensure that the web service works, we’ll consume it by calling it from our web application and see if it responds correctly. We’ll also cover how to validate our API with unit testing. Consume the API For the purpose of this demo, we’ll use , which is an open-source tool to test SOAP (and other protocols) web services. With SoapUI installed and running, we create a new SOAP Project, providing a name and selecting our file as the initial WSDL. SoapUI enterprise_wsdl.xml We now have all available Salesforce SoapBindings listed on the left. First, we need to authenticate our web application to Salesforce. We do this by using the call and providing our login credentials. login Use a security token For added security, we also need to add a to our password to authenticate. We can get a security token by going to the page and selecting on the left. Then, press the button with the same name. We will then receive our security token by email. Security Token Settings Reset My Security Token Log in with the token and credentials With our token in hand, we select the SoapBinding in SoapUI. Ensure you have the correct URL depending on your org. If you just signed up for a developer account, the URL should be . If you are testing this in a Sandbox, then the URL should be . Ideally, the generated Enterprise WSDL will already have the correct URL. login https://login.salesforce.com https://test.salesforce.com For demo testing, we can comment out all other parameters except username and password. We press the green button on the top left of the window to send the request. We receive a response that looks like this: Play The critical pieces that we are looking for in the response are and . In order to call our web service, we need to provide the together with other parameters in our call. We copy down this , as we will need this later. sessionId serverUrl sessionId sessionId Call our SOAP API Let’s call our class and create a Contact in Salesforce. To do this, we need to add our ContactAPI WSDL file, , to our project. We right-click on the project folder and select . ContactAPI contactAPI-wsdl.xml Add WSDL After adding the WSDL, it also appears in the left menu like below. Double-click on to see the request. For this example, we can remove everything from the SOAP envelope header except for the with node. Request 1 SessionHeader sessionId After removing the unwanted nodes, we provide the that we copied from our login call earlier. Then, in the section of the envelope, we provide the details of the contact to be created. sessionId Body We press the green button on the top left. Vóila! We have successfully created a Contact in Salesforce and received its . Play Id Check Salesforce org for new contact Let’s look inside our Salesforce org to see if everything was created correctly. We go to our Salesforce org, click the waffle icon on the left and then type in the search bar to find and select . App Launcher Contact Contacts By default, we land on the Contacts page with the list view. Click the down arrow and select either or list view. Recently Viewed Contacts All Contacts My Contacts : If you are in a Developer org, you will see a bunch of dummy Contacts (and other records) that Salesforce creates for you to test the platform. Note We type the name of our newly created contact in the list search box on the right, and we see our new contact! When we click on the Contact name, we end up on the Details page for that Contact. Call our SOAP API with invalid data Lastly, in order to ensure that our API is working properly, let’s send a bad request to see what we get as a response. We’ll simply send another request to our SOAP web service, but this time replace the in the email address with a instead. . , This time, we receive an (as we programmed in the API). error message The entire error message reads like this: Error:Insert failed. First exception on row 0; first error: INVALID_EMAIL_ADDRESS, Email: invalid email address: sheila@gmail,com: [Email] This shows that our SOAP-based API is working as designed. With this foundation, we can build other SOAP-based APIs to create records for different objects. Unit Testing Besides consuming our SOAP-based API, another way to validate it works properly is through testing. Test Driven Development (TDD) is at the core of Salesforce development. To ensure the stability and reliability of the platform, Salesforce requires your custom code to have a minimum of 75% code coverage via unit tests in order to deploy it to a production environment. Let’s create some unit tests for our web service. @isTest
private class TestContactWebService {
  static testMethod void testInsertNewContact() {
    // Create test data for positive test
    String salutation = 'Mr.';
    String firstName = 'Max';
    String lastName = 'Bond';
    String emailAddress = 'm.bond@mi5.gov.uk';
  
    Test.startTest();
    //Call the method with parameters
    String result = ContactAPI.createContact(firstName, lastName, emailAddress, salutation);
    Test.stopTest();

    Contact newContact = [SELECT FirstName FROM Contact WHERE LastName = 'Bond'];
    System.assertEquals(newContact.FirstName, 'Max', 'Assert Error: Please check the ContactAPI class');
  }

  static testMethod void testInsertNewContactFail() {
    // Create test data for failing test
    String salutation = 'Mr.';
    String firstName = 'Max';
    String lastName = 'Bond';
    // The email address has , instead of .
    String badEmailAddress = 'm.bond@mi5,gov,uk';
    
    Test.startTest();
  
    //Call the method with parameters
    String result = ContactAPI.createContact(firstName, lastName, badEmailAddress, salutation);
   Test.stopTest();

   // This should contain the Error substring that we added to the catch block above.
   System.assert(result.contains('Error:'), 'Fail Assert Error: Please check the ContactAPI class');
  }
} In our unit test, we created two scenarios: a “happy path” that verifies valid inputs result in a newly created Contact record, and a “sad path” where we expect the API to return an error on invalid inputs. Salesforce also provides a . Trailhead on unit testing in Apex Conclusion In this post, we only scratched the surface in terms of the capabilities that Salesforce provides when it comes to SOAP. As we saw, the generated Enterprise WSDL makes a long list of SoapBindings available. In addition, we can create our own custom classes and SOAP-based web services. If you have a (legacy) application that uses SOAP to communicate with other systems, you now have the tools to connect that application to your Salesforce org. With enterprise-level security baked into the platform, you can be sure that your connection is safe and your data is protected. In Part Two of our series, we’ll cover REST APIs, demonstrating how to use Apex to create a custom REST API endpoint for our Salesforce org.

Creating Custom API Endpoints in Salesforce with Apex

The projects that 4.2M new Salesforce-related jobs will be created between 2019 and 2024. A portion of these roles are Salesforce developer positions. But what’s the job of a Salesforce developer, and how do professionals transition into these roles? These questions– and workforce evolutions– are close to my personal experience. I had a conversation with to discuss these topics, as they’re part of her journey as well. In this post, we’ll discuss her history with the platform, and she’ll outline what a Salesforce developer job looks like today. Alba will also give you tips and tricks to successfully get started yourself. IDC Alba Rivas Alba began her path to Salesforce by studying telecommunications engineering, and she’s been developing software since she graduated. Early in her career, she worked on applications primarily built with Python and Java. But in 2014, Alba was contacted by a company who built apps on the Salesforce platform to sell through Salesforce’s app marketplace, . The company was looking for back-end developers. The native back-end language used in Salesforce is , an object-oriented domain-specific language similar to Java or C++. Because there weren’t many Salesforce developers in the market yet, the company was looking for developers with object-oriented programming skills. Alba told me that initially, she was reluctant to take the job. She was skeptical of a platform that had created its own programming languages. Ultimately, Alba finally decided to accept the offer and give it a chance. AppExchange Apex The Upsides of a Software as a Service Platform When Alba and I discussed the early days of her Salesforce developer work, she said she felt the benefits of developing on a SaaS (Software as a Service) platform from the very beginning. When developing apps with the Salesforce platform, Alba pointed out that you don’t have to take care of hosting your app. Developers don’t need to create and attach databases, start and stop web servers, or balance incoming requests. The Salesforce platform does all that for you. Becoming a Salesforce developer gave Alba the opportunity to invest her time in creating apps, which is what she told me she loves doing. Salesforce executes in a multi-tenant environment, meaning that the underlying resources are shared with other customers. The platform has well defined that prevent one environment’s code from hoarding the resources. These limits, Alba found, served as positive motivation in her development work. Developing in an environment with clear limits forces developers like Alba to write optimal code. She told me she’s always been an advocate of clean code, design patterns, and performance. So, learning how to code with Apex was fun for Alba– like doing a sudoku in which everything fits together nicely. limits Building Faster with Configuration and Builders Later in our chat, Alba and I talked about how on the Salesforce platform, there are two main ways to build apps: using configuration and coding. Thanks to this powerful combination, building apps on the Salesforce platform is extremely fast. When configuring an app, the objects, the table where they’re stored, the basic user interfaces and APIs for the app and their APIs are configured through a web application. No code is needed. This initial configuration produces an app that is basic, but could be used immediately in production. To implement the custom logic and UI for your app, you can further configure it. The tools for these configurations are referred to as “builders.” lets Alba and other Salesforce developers assemble pages with web components. These can be out-of-the-box components, components downloaded from the AppExchange, or custom components built by them. Lightning App Builder For custom business logic and business processes, Alba likes to use . Flows are units of logic build with a block-based programming interface. Flows can be configured to be executed when a record is modified, or through other entry points. For instance, Alba talked about how they can be invoked from Apex and how they are also exposed for execution from a REST API call. Flow Builder Flows can also incorporate UI to create complex guided visual experiences with no code. These are called “Screen Flows.” These builders vastly speed up the app creation process. At this point in our conversation, Alba acknowledged that traditional coders might be wary of what she was saying. But she encouraged me (and you) to think of builders as a booster to speed up development. She pointed out that you can quickly build basic, less interesting functionality with no code, freeing up developers to concentrate on solving more complex and challenging problems with code. At this point, I asked Alba how much time a Salesforce developer invests in coding alone. She said it can depend on many factors. Primarily, it depends on the structure of the company that you work for. In Alba’s case, she has always dedicated 95% of her time to code, as there haven’t been other people in her company whose role it was to do the configuration. Having said that, she acknowledged this is not always the case. Transferable Skills for Programmatic Development When Alba started with Salesforce development, the supported coding languages were Apex to implement business processes and (a server-side rendering framework with its own custom markup) to create pages. Visualforce Now in Alba’s role, she and her team use (LWC) to create custom user interfaces, a framework based on . With LWC, Alba creates components using modern, standard JavaScript. This means the skills that she learned previously are transferable to other JavaScript-based technologies. She pointed out that on top of this transferability, LWC is , and developers can use it outside of the Salesforce platform. Components can be used in Lightning App Builder and published on the AppExchange for other customers to use them. Lightning Web Components Web Components standards open source We also talked about how the door has been opened to other back-end programming languages (beyond Apex) thanks to . With this new technology, developers are able to, from different Salesforce entry points, invoke functions written with standard-industry languages like Node.js or Java. These functions run elastically, using the exact resources that they need. Salesforce Functions Improved Developer Experience I asked Alba about the most noticeable Salesforce developer improvements she’s seen over the years. According to her, it boils down to the developer experience. When she started coding with Salesforce, it was normal to code in a limited, web-based IDE called the . (Developers could also use the ANT-based migration tool to deploy their changes to Salesforce.) While using the migration tool brought Alba the familiarity of ANT, there were limited capabilities for tracking changes and performing conflict resolution. Developer Console Force.com Alba told me the launch of in 2016 fixed a lot of the earlier limitations. In addition to change tracking and improved conflict resolution, the Salesforce CLI introduced features to manage Salesforce environments, run tests, load sample data, and much more. By using the Salesforce CLI, Alba said she became much more productive. This also helped her team to transform their application lifecycle management, as the Salesforce CLI allows developers to implement modern CI/CD flows much easier. Salesforce has also invested in the . Alba listed some of the extension’s benefits which included autocompletion capabilities, direct access to the help feature, tools for debugging, testing, and access to many of the Salesforce CLI features. the Salesforce CLI Salesforce extension pack for VisualStudio Code Tons of Free Learning Resources Since I know many developers are anxious about their time to productivity when switching roles, I asked Alba about this. She said that in her first months as a Salesforce developer, she invested some time into learning, but that honestly, the learning curve was not too steep. There was great documentation, developer guides, and other training materials that she could find online. This onboarding experience has vastly improved thanks to . Trailhead is Salesforce’s fun, free learning platform in which developers can learn by following interactive tutorials, all while getting up to speed lightning fast. It contains more than 1000 learning modules and hands-on projects. Trailhead The Invaluable Salesforce Community In thinking about Salesforce’s size, I asked Alba whether she felt it was a benefit or drawback. Alba described it as an appealing differentiating factor– the community around Salesforce is huge. So, if you have a question, you can ask it in a public community, such as the online , the , or , and lots of folks will be happy to quickly help you. Alba also pointed out that developers can join a near where they live and connect with people at online and in-person events. She said that Salesforce Community members normally have a spirit of cohesion; they look out for each other. Being involved in the community was key in her own learning path, and it also helped Alba to join the developer relations team at Salesforce, where she works as a developer advocate today. Trailblazer community Developer Forums Salesforce Stackexchange Trailblazer community group Next Steps If you want to get started with Salesforce development, Alba recommends starting with . In addition to Trailhead, Salesforce publishes lots of development resources to read, watch, and listen to. Alba also suggested this developer’s blog, the Salesforce , and their (subscribe if you haven’t yet!). Alba specifically encouraged new Salesforce developers to take a look at the and video series. Want to take a look at some sample code? Salesforce has with patterns and best practices to help you ramp up your development skills. the Developer Beginner trail podcast Youtube channel Beginner’s Mind Quick Start sample apps I hope you enjoyed reading this post as much as I enjoyed connecting with Alba. Best of luck in following her path toward becoming a Salesforce developer. Have a really great day!

The Journey to Becoming a Rockstar Salesforce Developer

(LWC) from Salesforce are based on standard built using HTML and JavaScript. They are lightweight, easy to build, and perform well in modern browsers. When building LWCs, you’ll become familiar with the concept of : piecing together simple building-block components within the body of a more complex component. Lightning Web Components Web Components composition Regarding composition, LWC leverages the (DOM) web standard, which encapsulates the internal structure of a Web Component and makes it inaccessible to code and components outside of the component. The alternative to this approach is , which Salesforce makes available in beta. Shadow Document Object Model Light DOM In this post, we’ll explore in detail the concept of Light DOM in Salesforce development. We’ll begin with an overview of the DOM concept, followed by the differences between Shadow DOM and Light DOM. Finally, we’ll look at how this plays out in LWC, along with how to implement Light DOM in LWC. What is the DOM? Taking the definition from , the DOM is .” That means: The DOM provides a way to represent a web page in a tree-like structure as nodes and objects. This makes it easier for developers to manipulate and build out any logic as required. MDN “the data representation of the objects that comprise the structure and content of a document on the web Image Source It’s important to note that the DOM is independent of any programming language. A web application built using any language or framework would typically provide access to the DOM and its components in one way or another. The Shadow DOM Perhaps you’ve come across the “Shadow DOM”, which is basically an extension of the DOM that allows hidden DOM trees to be attached as elements in the regular DOM tree. MDN uses this graphic to represent the Shadow DOM: Image Source The intent of the Shadow DOM is to provide encapsulation for an individual component in the DOM, keeping the markup structure, style, and behavior of that component hidden and separate from other code on the page. Developers can share that component as a full DOM tree (“shadow tree”), ensuring that no outside code can manipulate that tree. This helps keep the code well segregated and avoids clashing. Light DOM versus Shadow DOM The term “Light DOM” is just another name used for the normal or regular DOM, to distinguish it from the Shadow DOM. The “Shadow Boundary” separates the Light DOM from the Shadow DOM. LWC, just like any Web Component, enforces the on every component. By using the approach, which is currently a feature in beta Service and generally available only for Salesforce Experience Builder sites, components are attached to the host element instead of its shadow tree. Shadow DOM Light DOM Let’s look at what this means in greater detail. Shadow DOM in LWC Because the Shadow DOM web standard is not implemented in all browsers that Salesforce supports, LWC uses a Shadow DOM polyfill named Synthetic Shadow DOM. The following markup shows a sample shadow tree structure: <c-my-app>
  #shadow-root
    <div>
        <p>My Tasks</p>
    </div>
    <c-my-item>
      #shadow-root
        <div>
            <p>Item 1</p>
        </div>
    </c-my-item>
</c-my-app> Shadow DOM prevents us from extracting DOM elements by using references to or . Instead, an LWC component needs to access the tree by using . document document.body this.template.querySelector() CSS is also affected by Shadow DOM encapsulation. Style from outside of the component can only affect the top level of the component and cannot affect parent, child, or sibling CSS. The LWC architecture leverages Lightning Locker Service to enforce DOM access containment. Components are segregated from one another by using namespaces, and each component can only traverse its DOM and access elements in the same namespace. This is a significant limitation (albeit intentional), making the component inaccessible to programmatic code. This measure prevents script injections and style leaks. Light DOM allows developers to circumvent this security restriction. Light DOM in LWC To lift DOM access restrictions imposed by the Shadow DOM, Salesforce has introduced the concept of working with Light DOM in LWC. Even though the feature is currently in beta, it’s clearly the way forward for DOM manipulation for LWCs. The idea is this: Since the LWC resides outside the Shadow DOM, none of the Shadow DOM limitations apply to the component. Below is a brief comparison of how Shadow DOM and Light DOM impact an LWC. Feature Light DOM Shadow DOM Global CSS Theming with a master style sheet Full Support No Support, CSS is defined at component level and does not cascade. Third-Party Tools Full Support for DOM traversal Limited support as third-party tools can only access their parent component. Programmatic DOM Access Not limited by namespace Limited by namespace Portability Portable but cause breaking changes Portable with secure access Highly Customizable UI Good fit Not a good fit Light DOM in LWC: An Example Let’s look at a simple example of how Light DOM works with an LWC component. This is a simple template directive for a MyApp LWC that uses the Shadow DOM by default. <template>
    <my-header>
        <p>My Tasks</p>
    </my-header>
</template> To enable light DOM, we simply need to set the property as follows: renderMode import { LightningElement } from 'lwc';

export default class MyApp extends LightningElement {
    static renderMode = 'light';
} Next, we change our template directive to use Light DOM instead of Shadow DOM: <template lwc:render-mode='light'>
    <my-header>
        <p>My Tasks</p>
    </my-header>
</template> Accessing Elements using Light DOM in LWC Elements can be accessed in Light DOM using the method. This is a powerful way for developers to access and manipulate elements as needed. document.querySelector() In Light DOM, we would use . In Shadow DOM, we would need to use . this.querySelector this.template.QuerySelector Event Propagation using Light DOM in LWC When it comes to event propagation, Light DOM is a big uplift for developers. Shadow DOM retargets any events which cross the shadow boundary. There is no such event retargeting in Light DOM, and it’s easy for developers to identify the exact UI element that triggered an event instead of getting a reference to the underlying component. Guidelines for using Light DOM in LWC Salesforce has provided a set of guidelines and limitations for developers using Light DOM, which you can find . here Conclusion LWC provides a simple and powerful approach to crafting complex web components. Up to this point, while Salesforce has used the Shadow DOM standard in LWC for the purposes of encapsulation and secure access, developers may encounter many scenarios in which the Light DOM approach is fitting and appropriate. With Light DOM now offered in beta, Salesforce developers can now make the choice for themselves based on their use case.

Light DOM and Lightning Web Components in Salesforce

The Salesforce development platform offers many powerful features to provide your team with apps that can unlock new workflows. For many years, the platform has run on a trifecta of technologies: (to view the data), (to handle the data), and Salesforce itself (to store the data). Visualforce Apex Apex is like many other object-oriented languages, and it has a Java-like syntax. However, , allowing developers to build and deploy an app without worrying about where to host it or how to secure their data. Apex runs directly on Salesforce servers The challenge of Apex and long-running commands Applications built on Salesforce run on its , so . With shared resources, however, wouldn’t it be possible for the code for one org’s app to consume so much processor time and memory space that it affects other users in that same org? An example of this could be a command that takes several minutes to complete. multitenant architecture server resources like CPU and memory are shared among different organizations Salesforce prevents situations like this from occurring by restricting how apps on its platform run. Long-running programs can potentially interrupt other work by hogging the limited resources available. If any app has the potential to interfere with other users, it is restricted from completing its command execution. If so, how might Salesforce developers build apps that execute long-running commands which can scale with user growth while not impacting performance? Salesforce Functions to the rescue Enter , which are small programs and deployed onto Salesforce’s servers. Functions can perform the resource-intensive work and be invoked directly from Apex. When the Salesforce Function completes the request, it can send its results back to the originating Apex application, which then performs any additional tasks on those results. Salesforce Functions written in JavaScript, TypeScript, or Java Salesforce Functions and on the Salesforce platform. The , allowing you to execute longer running and more complex tasks. Because Salesforce Functions run on the Salesforce platform, security is baked in; there’s as everything runs within the same trust boundary. run in their own container don’t affect other tenants memory and CPU limits are much higher no risk of privacy loss In this article, we’ll take a closer look at how to migrate a long-running Apex operation into a Salesforce Function, along with some general tips around the Salesforce DX suite. Prerequisites This article will require you to have some understanding of both Apex and TypeScript, but don’t worry if you’re not an expert. We’ll go through every piece of code to explain what is happening. Although the completed version of our code is available as , you may also want to download some of the CLI tools which Salesforce provides to follow along (or for your own future projects). a GitHub repository First, install , which is a tool that helps simplify common operations for Salesforce developers when building applications. the sfdx CLI It’s important that whatever you build and deploy doesn’t affect your “real” production Salesforce organization. So, create a separate that this app can interact with. To get your own scratch org, sign up for account. scratch org a free Developer Edition To use Salesforce Functions, you’ll need to by contacting your Salesforce account executive. register for a Salesforce Functions trial Finally, you can also install to make deploying your code a little bit easier. This step is optional. the Salesforce VS Code extension Touring the existing code Open up the file at and take a look at its contents: force-app/main/default/classes/Dogshow.cls public class Dogshow {
   public static void updateAccounts() {
       // Get the 5 oldest accounts
       Account[] accounts = [SELECT Id, Description FROM Account ORDER BY CreatedDate ASC LIMIT 5];

       // Set HTTP request
       HttpRequest req = new HttpRequest();
       req.setEndpoint('https://dog.ceo/api/breeds/image/random');
       req.setMethod('GET');

       // Create a new HTTP object to send the request object
       Http http = new Http();
       HTTPResponse res = http.send(req);

       String body = res.getBody();

       Map<String, String> m = (Map<String, String>) JSON.deserialize(jsonStr, Map<String, String>.class);
       String dogUrl = m.get('message');

       // loop through accounts and update the Description field
       for (Account acct : oldAccounts) {
           acct.Description += ' And their favorite dog can be found at ' + dogUrl;
       }

       // save the change you made
       update accounts;
     }
} These 30 lines perform a fairly simple function: It grabs the five oldest Salesforce accounts using SOQL. It issues an HTTP request to , which is a site that returns a JSON object with a random URL link to a very cute dog. https://dog.ceo/dog-api/ The Apex code then updates the description for those five accounts to indicate that dog is their favorite. that This code is fairly innocuous, but it introduces two situations that present some real problems: When issuing an HTTP request, several factors can affect your program. For example, the server you issue requests to could be overloaded and slow to respond. While your own code may be performant, you’re at the mercy of anything outside of your control, such as an external data source. Although we only iterate on five accounts here, what if we built an app that needed to iterate over 500 or 5,000? Looping through them one by one would be a slow, albeit unavoidable, process. This is an opportunity for a Salesforce Function to take over some of this work. Our Apex class can provide a list of accounts to update to a Salesforce Function. That Salesforce Function can then issue HTTP requests and update the accounts. Before seeing what that full migration might look like, let’s first write that Salesforce Function. Developing the Salesforce Function Using the sfdx CLI, we can easily using a single command: create a new Salesforce Function in TypeScript $ sf generate function -n dogshowfunction -l typescript This creates a set of files under . The most important of these is , which is where our main Salesforce Function code will reside. However, the other files are also important, dealing with testing and linting code, as well as defining TypeScript generation and the Salesforce deployment process. functions/dogshowfunction index.ts Let’s focus on . In this file, you’ll note that there’s one function exported, and it takes three parameters: index.ts : This describes the payload of data that is coming in from your Apex code. event : This contains the authorization logic necessary to communicate with Salesforce. context : This is a simple logger that also . logger integrates with Salesforce The template code which the CLI generates shows how powerful Salesforce Functions are: They can accept any JSON data sent over from Apex. They can work directly with Salesforce data. They integrate directly with the platform in such a way as to handle all the authentication and security for you. Best of all, since this particular function runs on Node.js, you can to supplement your code. Let’s do that right now by installing to issue our HTTP request: install and use any NPM package node-fetch $ npm i node-fetch Our Salesforce Function will be responsible for issuing our HTTP requests and updating our five accounts. To implement that functionality, our function might look something like this: export default async function execute(event: InvocationEvent<any>, context: Context, logger: Logger): Promise<RecordQueryResult> {
   const accounts = event.data.accounts;

   accounts.forEach(async (account) => {
       const response = await fetch('https://dog.ceo/api/breeds/image/random');
       const data = await response.json();
       const message = ` And their favorite dog is ${data.message}`

       const recordForUpdate = {
           type: 'Account',
           fields: {
             id: account.id,
             Description: `${account.Description} ${message}`
           }
         }
       context.org.dataApi.updateRecord(recordForUpdate);
   });
} Let’s break down what’s going on in the code snippet above. Our event argument is essentially a JSON object which we will define in our Apex code. Although this JSON object doesn’t exist yet, we can assume that it will have the and of the account we want to update, based on the behavior of our previous Apex code. id Description From here, it’s important to note that the context argument is essentially . Since we can assume that this account data is provided as an array, we can simply iterate through each item, plugging in the record data as part of our update command. an instantiation of the Node.js SDK for Salesforce Functions Migrate the Apex Code With our Salesforce Function defined, we can now replace the previous Apex logic with a call to this new function. Issuing a call to a Salesforce Function is surprisingly simple: We only need to know the name of our function and provide the data we want to send it, as shown below: public class Dogshow {
   public static void updateAccounts() {
       // Get the 5 oldest accounts
       Account[] accounts = [SELECT Id, Description FROM Account ORDER BY CreatedDate ASC LIMIT 5];

       // Set up the function
       functions.Function dogshowFunction = functions.Function.get('ApexToSalesforceFunctionsMigration.dogshowfunction');

       // Create a list to hold the record data
       List<Map<String, String>> jsonObj = new List<Map<String, String>>();
       for (Account account : accounts) {
           Map<String, Object> obj = new Map<String, Object>();

           obj.put('id', account.Id);
           obj.put('Description', account.Description);

           // Add an object to the record list
           jsonObj.add(obj);
       }
       // Send the record list to the function
       functions.FunctionInvocation invocation = dogshowFunction.invoke(JSON.Serialize(jsonObj));

       // if the function had a return value, it would be available here
       invocation.getResponse();
     }
} Just like that, we’ve taken the long-running operation out of our Apex code and offloaded it to a Salesforce Function. Now, we can be certain that our operation will continue to run even though it uses resources more heavily. The implications of Salesforce Functions cannot be overstated. With Salesforce Functions handling our need for time-consuming, resource-heavy operations, apps built on the Salesforce platform now have much more potential for scaling up seamlessly. Conclusion Salesforce Functions provide a way to improve workflows while building effective and durable projects. Without the memory and CPU limits you would experience in Apex, you can leverage Salesforce Functions for the execution of long-running commands, bringing scalability without a negative impact on performance. We’ve only begun to discuss the amazing capabilities provided by Salesforce Functions. To learn more about them, Salesforce Functions provides plenty of , along with various that are worth looking into. guides detailing specific tasks Trailhead recipes

Scaling Your Compute Resources on Salesforce

Caching is a strategy that can help you conserve resources and improve performance. When you have an oft-run expensive query with a result that seldom changes, caching is an ideal solution. By caching the result of that query, you can return the cached result when necessary. The result is the same, but you save the need to run the expensive query. Everybody wins. In this article, we will walk through the use of Salesforce Functions to cache expensive queries. For instance, we want to query for some value across a large number of records, and the page requiring this query is often loaded. However, the result will not change from one query execution to the next. Introduction to the Problem In our demo, the example query will be “ .” We imagine a use case in which there’s a page that our sales team loads often, and part of the page shows the total number of companies in our Salesforce org that match this condition. the number of companies with more than 10,000 employees Ideally, the expensive query is not run every time the page loads, but instead, we would implement a caching mechanism. To solve this, we will: Leverage to sync our list of companies from Salesforce to (or use a table already in Postgres). Heroku Connect Heroku Postgres Create a to query Postgres and return that count. Salesforce Function Store the resulting value in for a specified amount of time. Heroku Redis Use a Salesforce Function to check for the value in Redis. If the value exists in Redis, then return it. If not, then run the query and store the result in Redis. The data flow looks like this: Of course, Apex does have a for facilitating caching for certain use cases. For our use case—and for demo purposes—we’ll explore this caching solution that uses Salesforce Functions. Platform Cache API Before we proceed, let’s briefly introduce each of the pieces in our system. : A feature of Salesforce that allows you to run some code (JavaScript or Java are currently the supported languages) that is still in the secure area of your Salesforce org, but is . This allows you to offload workloads that are heavy or may cause you to exceed limits. Salesforce Function not running on your org : A tool within the Salesforce family for bidirectional data syncing between your Salesforce org and . Similar to Salesforce Functions, you can leverage this tool without impacting your Salesforce limits. Heroku Connect Heroku Postgres : A fully managed instance of (a relational database) on Heroku. Heroku Postgres PostgreSQL : A fully managed instance of (an in-memory key-value store) on Heroku. Heroku Redis Redis Prerequisites To use all of the above components, you must have the following pieces in place: A Heroku account A created, with and add-ons attached Heroku app Postgres Redis A Salesforce org with Functions enabled A local Salesforce Functions development environment [Optional] syncing to Postgres (a sample dataset is provided) Heroku Connect With the prerequisites in place, we can start connecting them. First, we’ll walk through connecting the environments. Then, we’ll look at the code needed to make the magic happen. Accessing Heroku Data Services from a Salesforce Function With your accounts and access in place, we can move forward with the Function itself. Let’s assume that you are starting a fresh project and have an empty Postgres database. If you are new to Functions, then we recommend going through this basic process to get a feel for things before you involve additional parts. If you already have a Salesforce project or are syncing the data via Heroku Connect, then you can modify the following commands to suit your needs. First, create a Salesforce DX project to give your function a home. sfdx force:project:create -n MyDataProj Next, navigate to the project directory and run the following command to create a fresh JavaScript function. sf generate function -n yourfunction -l javascript This will create a folder with a Node.js application template. /functions Next, associate your Salesforce Function and your Heroku environments by adding your Heroku user as a collaborator to your Function’s compute environment: sf env compute collaborator add --heroku-user <yourherokuaccount@email.com> The environments can now share Heroku data services. Next, you will need to obtain the name of the compute environment so that you can attach the datastores to it. sf env list To attach the Heroku datastores, you also need the names of the add-ons. You can get the name of the add-ons with the following command: heroku addons -a <yourherokuapp> The output will look similar to the following. The “name” of each add-on is shown in purple (for example, ). postgresql-closed-46065 With the names of the compute environment and your add-ons, run the following commands to attach Postgres and Redis to your compute environment: heroku addons:attach <your-heroku-postgres-name> --app <your-compute-environment-name>

heroku addons:attach <your-heroku-redis-name> --app <your-compute-environment-name> Now that we have connected our Salesforce Function environment with our Heroku datastores, we can write our Salesforce Function code. Implementing the Salesforce Function Before we begin writing the JavaScript for this Salesforce Function, let's set up our local development environment with the necessary libraries. In the deployed environment, our Function will get the data connection information from environment variables. For our local environment, we will use the node package to read a file named with this information. We can create that file with the following command: dotenv .env heroku config -a <yourherokuapp> --shell > .env Next, let’s install the packages we need to interact with Postgres and Redis, along with dotenv: npm install dotenv pg redis Our project setup is done. Let’s write our function code. Connect to Heroku Postgres and Redis Let’s start by adding the code that allows us to read and store data in Heroku Postgres and Heroku Redis. (Note: The has some helpful documentation on connecting to and from Node.js.) Heroku Devcenter Postgres Redis Our function code will live in the file of the folder in our project (for example, ). We open that file and add the following lines to the top. These lines will import the modules we just installed. index.js functions MyDataProj/functions/index.js import "dotenv/config";
import pg from "pg";
const { Client } = pg;
import { createClient } from 'redis'; The main part of the function is the section that is being exported. The value returned from this block will be returned to the caller of the function. export default async function (event, context, logger) {

} To keep our code clean and modular, let’s first write several helper functions at the bottom of the file. We need functions that we can call to manage our connection to Postgres and Redis. Under (and outside of) the exported function, we add the following two helper functions: /* Helper functions */

// Connect to PostgreSQL
async function pgConnect() {
   const DATABASE_URL = process.env.DATABASE_URL;
   if (!DATABASE_URL) {
     throw new Error("DATABASE_URL is not set");
   }
    const client = new Client({
     connectionString: DATABASE_URL,
     ssl: {
       rejectUnauthorized: false
     }
   });
    await client.connect();
   return client;
 }

// Connect to Redis
async function redisConnect() {
   const REDIS_URL = process.env.REDIS_URL;
   if (!REDIS_URL) {
     throw new Error("REDIS_URL is not set");
   }
    const redis = createClient({
       url: process.env.REDIS_URL,
       socket: {
           tls: true,
           rejectUnauthorized: false
       }
       });
    await redis.connect();
   redis.on('error', err => {
       console.log('Error ' + err);
   });
   return redis;
 } Load in a sample dataset To keep our example simple, let’s load a small dataset into Postgres. We can create a table called “company” by running the database commands found in the following . gist Download the contents of that gist to a file called . To run the database commands from the Heroku CLI, do the following: company.sql heroku pg:psql -a <yourherokuapp>

DATABASE=> \i /path/to/company.sql You can verify that your sample dataset has been loaded by running the following query: DATABASE=> select * from company; Write the Main Function We’re all set up! Now, we just have a little bit of code to write for our actual function. The code for our function is available as a and looks like this. You can copy this into your file. gist index.js We’ll step through and explain each section of the code. export default async function (event, context, logger) {
   logger.info(`Invoking Datafunction with payload ${JSON.stringify(event.data || {})}`);

   const redis = await redisConnect();
   let cached = {};

   // Check Redis for cached entry first
   let big_biz_count = await redis.get(`big_biz`);

    if (big_biz_count) {
       // If cached entry found, return it and be done.
       logger.info(`Found cache entry = ${big_biz_count}`);
       cached = "true"
       redis.quit();

       return { big_biz_count, cached }
   }  else {
      // If cached entry not found, then:
      // 1. Run the Postgres query
      // 2. Store the result in Redis
      // 3. Return the result and be done
       logger.info(`did not find in cache, returned ${big_biz_count}`);
       cached = "false"
       const pg = await pgConnect();
       const { rows } = await pg.query('SELECT COUNT(*) FROM company WHERE employees>10000;');
       big_biz_count = rows[0].count.toString();

       redis.set(`big_biz`, big_biz_count, {
         EX: 30, // seconds to keep before expiring
         NX: true
       });

       // Close the connections   
       redis.quit();
       pg.end();

       // Return the value from Postgres, now stored in Redis
       return { big_biz_count, cached }
   }
} An Explanation of the Code As mentioned at the beginning of this article, we want to find out how many companies have more than 10,000 employees and return that number. We want to cache the number because it is an “expensive query”. In our example, the table is small, so it is not that expensive. However, it represents an “expensive query” that we may want to run in real life. You get the idea. Let’s walk through the main sections of our function code. Connect to Redis and see if the value is there. const redis = await redisConnect();
  let cached = {};
  let big_biz_count = await redis.get(`big_biz`); If the value is there, meaning it has been cached, then we can return the cached value and be done. if (big_biz_count) {
    cached = "true"
    redis.quit();
    return { big_biz_count, cached } If no cached value was found, then we have no choice but to run the query on our Postgres database. }  else {
    cached = "false"
    const pg = await pgConnect();
    const { rows } = await pg.query('SELECT COUNT(*) FROM company WHERE employees>10000;');
    big_biz_count = rows[0].count.toString(); Then, we store the value returned from our query in Redis. redis.set(`big_biz`, big_biz_count, {
      EX: 30, // seconds to keep before expiring
      NX: true
    }); Finally, we close our datastore connections, and we return the query result. redis.quit();
    pg.end();
    return { big_biz_count, cached } You might prefer to refactor the code a little bit or add some error handling. However, at this most basic level, that’s all there is to it. Test the Function Now that we have a Salesforce Function, we can test it locally. First, we start up the function server. sf run function start Then, we invoke the Function with a payload from another terminal. sf run function -l http://localhost:8080 -p '{"payloadID": "info"}' When you invoke the function against the test database for the first time, you should see the following output because there was no value in the cache: After this first run, however, the value is stored in our Heroku Redis instance. A subsequent run of the Salesforce Function returns the same value, but this time, is true. cached When we added the value to Redis, we set the cache expiration to 10 seconds. This makes it easier to test. However, in a real-world environment, the lifespan of your cache values should make sense for your business use case. For example, if the result changes after a nightly run of a report, then you could set the cache value to expire every 24 hours. Better yet, you can create another Salesforce Function that updates the cache with the new value as soon as the report finishes. The entire contents of index.js can be downloaded . here Conclusion We did it. Caching is an excellent strategy for reducing resource load while providing faster responses. With Salesforce Functions, we can connect our Salesforce orgs to Heroku datastores (such as Postgres and Redis) and build mechanisms for caching. Salesforce Functions allow us to perform tasks that might ordinarily be load-heavy, cause timeouts, or exceed other limits imposed by Salesforce. Caching is just one use case, but it can yield tremendous benefits, and it’s easy to implement. Now, go have fun with it! Photo by on Nate Grant Unsplash

Salesforce Functions for Caching Expensive Queries

Part One: Java Calling Salesforce The Salesforce ecosystem is pretty massive. Developers need to work hard to stay up-to-date with the latest and greatest features and tools coming from Salesforce. In this article, we’ll mix a little bit of the and the . We’ll combine Java-based applications with Salesforce, and we’ll do so via web services. old new Java is a programming language and computing platform first released by Sun Microsystems back in 1995. Since then, we’ve seen the rise of Web 2.0 and web programming languages, containers, microservices, and cloud-native architectures. Yet even now, many new products and digital services designed for the future continue to rely on Java. Java will be around for the foreseeable future. Meanwhile, Salesforce has established itself as the world’s top CRM and customer success platform. With today’s enterprises relying on multi- and hybrid-cloud setups with applications that need to integrate seamlessly with one another, it’s not surprising that Java applications and the Salesforce Cloud need to intersect. So how do we get our Java and (SFDC) applications integrated and talking with one another? Salesforce.com In this article, we’ll discuss how to implement this integration using the Web Services Connector (WSC). We’ll use an example use case—a business that wants to use its Java application to manipulate Salesforce org data—and show you how to set up your developer environment and connect the pieces. However, before we start, let’s talk briefly about Salesforce and its API-first approach. Salesforce and the API-first Approach If you’re familiar with the SFDC ecosystem, then you will know that Salesforce takes an API-first approach when building features on its platform. In fact, Salesforce was to deploy web APIs! While the platform has many great built-in capabilities, Salesforce wants to enable its customers to create the capabilities and custom experiences they need for their own platforms. By offering APIs, Salesforce ensures that SFDC can be customized and connected to any external application that can interact with web services. Some of the APIs from Salesforce (and there are of them) include: one of the first companies a lot SOAP API REST API Bulk API Metadata API Chatter REST API Streaming API Tooling API Suffice it to say that Salesforce has its platform pretty well-covered by APIs, opening up access to its capabilities for countless different use cases. That being said, let’s dive into our use case. In our example use case, we have a Java application that helps a business generate leads for their sales organization. That business would like the Java application to push the qualified leads directly to their Salesforce CRM, avoiding the need for manually entering lead data into Salesforce. To integrate Java and Salesforce, we’ll use the Salesforce SOAP API and the library, which serves as a wrapper layer that simplifies working with the API in Java. Web Services Connector (WSC) Initial Setup The initial setup of our Java developer environment requires taking several steps. Fortunately, we had guidance from this . Nonetheless, we’ll provide an overview of the major steps here. Salesforce tipsheet Install the Java Developer Kit (JDK) To use Salesforce APIs in our Java application, we’ll install the Java Developer Kit (JDK) at version 11.0 or later. You can do that by visiting and finding the appropriate binary for your local machine. this page Install Eclipse Next, you’ll need a Java development IDE. While there are several options available to you, the steps for our walk-through will go with the Eclipse IDE. You can find the latest Eclipse IDE packages . Download and install the IDE on your local machine. here Install the WSC Since we’ll be using the Salesforce SOAP API, we need to install the WSC. Download WSC pre-built .jar files The for the WSC shows all of the versions available: Maven repository Navigate to the page for the version that that you’re using. In our example, we’ll use . matches the API version of Salesforce 56.0.0 Under , we click on . This takes us to the of actual files we will need to download. Files View All ` .jar Download the following four files to your local machine: force-wsc-56.0.0-javadoc.jar force-wsc-56.0.0-sources.jar force-wsc-56.0.0-uber.jar force-wsc-56.0.0.jar We will use these files to generate stub files with the WSDLs from our Salesforce org. Generate and download the WSDL for your Salesforce org Next, we’ll generate an WSDL to use in generating our .jar stub files. We can’t use pre-built .jar files here because the WSDL is specific to our Salesforce Org. If there are custom objects and fields defined in our Org, then the WSDL will reflect those, and the generated .jar will contain them. We log into our Salesforce developer organization. Then, we navigate to , , , . We click on “Generate Enterprise WSDL.” Setup Platform Tools Integrations API This will open a new tab in your browser, displaying your WSDL file. Save this file to your local machine with the name . Put it in the same folder where you downloaded the WSC .jar files. sfdc.wsdl Generate Java stub file To use the SOAP API with Java, we need to generate .jar stub files for use in our application project. We run the following command to generate the stub file: $ java -classpath force-wsc-56.0.0-uber.jar com.sforce.ws.tools.wsdlc sfdc.wsdl sfdc_stub.jar

[WSC][wsdlc.main:72]Generating Java files from schema ...
[WSC][wsdlc.main:72]Generating 1206 java files.
[WSC][wsdlc.main:72]Compiled 1210 java files.
[WSC][wsdlc.main:72]Generating jar file ... sfdc_stub.jar
[WSC][wsdlc.main:72]Generated jar file sfdc_stub.jar Create Java Project in Eclipse In Eclipse, start a new Java project and a new Java class, , using the following code: Main package wsc;
// Depending on wsdl chosen, change this to enterprise or partner
import com.sforce.soap.enterprise.*;
import com.sforce.soap.enterprise.sobject.*;

import com.sforce.ws.*;

public class Main { 
  public static void main(String[] args) {
    ConnectorConfig credentials = new ConnectorConfig();
    credentials.setPassword("YourPassword!apPenDdedSecurityToken);
    credentials.setUsername("yoursalesforceusername@yourdomain.com");

    EnterpriseConnection connection;
    try {
      connection = Connector.newConnection(credentials);
      Lead le = new Lead();
      le.setLastName("AcmeEnterprises");
      le.setCompany("JavaPush");
      le.setIndustry("Hospitality"); 
      connection.create(new Lead[]{ le });
    } catch (ConnectionException e) {
      e.printStackTrace();
    }
  }
} Add .jar files to project Next, we need to connect the generated four .jar files with the build path for our project. Right-click on your project and select , . Build Path Configure Build Path In the modal that comes up, navigate to in the left side panel. Click on the tab. Select , and then click the button. Find the four .jar files that you downloaded from the Maven repository and the generated stub file ( ), and add them. Then, click on . Java Build Path Libraries Modulepath Add External JARs sfdc_stub.jar Apply and Close Test the Application We are all set up, with our code and our .jar files all in place. Now, right-click on your file in Eclipse. Select -> . Main.java Run As Java Application After we run our application, we navigate to Sales in our Salesforce org, and we see that we have a new lead! Leads Our Java application has successfully tapped into our Salesforce org through the SOAP API, using the WSC to insert a new lead! Next Steps Now that we have verified the initial proof of concept, you can begin expanding your Java application to perform other operations, including reads, updates, and deletions. You can incorporate your own custom business logic to create a Java application that handles your Salesforce org data for you! For more information on many of the core concepts we covered, here are links to helpful resources: Web Services Connector (GitHub) Salesforce Master GitHub Repo (a treasure trove of SFDC repositories)

Build a Java Backend that Connects with Salesforce

When people research new tech tools and platforms to use, Salesforce and NetSuite are two options they’ll almost certainly come across. Here’s what individuals should know about these products to make confident decisions about using them. Team Collaboration Tech platforms must help employees get work done by pooling their efforts — especially with more team members working remotely or across various locations. When comparing these two products for their collaboration potential, Salesforce has more built-in features. For example, users can , projects or other needs. They can then share content, receive suggestions from employees or launch polls. Salesforce also lets people work together on sales opportunities and marketing campaigns. create specific groups for teams NetSuite’s collaborative features mostly come from how it allows people to connect other products to the platform. Wrike, Microsoft Teams and DocuSign are a few of the many products people can set up to work with NetSuite. When people know they can use NetSuite with other products they know well, it’s easier for their productivity to stay high. Scope of Functionality Most people define Salesforce as a customer relationship management (CRM) product, whereas NetSuite centers on enterprise resource planning (ERP). Salesforce’s website clarifies that an ERP component. In contrast, NetSuite its ERP functionality. it does not have has a dedicated page describing As its name suggests, customer relationship management focuses on all the ways a customer interacts with a business. Enterprise resource planning is more extensive, giving people access to oversight and management capabilities for all the assets they need to keep a company operating successfully. A best practice for evaluating any ERP solution is to identify across departments and which features are merely nice to have. However, that advice could easily extend to Salesforce or any other CRM platform, too. People should ideally create a list of their must-have features and ones they’re willing to compromise on if necessary. Doing so will help them make more confident decisions. what functionality is vital to operations Productivity and Automation Salesforce and NetSuite have numerous features helping people make the most of their time, including automation. For example, Salesforce has Einstein Automate. It’s a workflow solution that allows employees of the desired responses to those actions. to build triggers and specifications Einstein Automate is a low-code tool enabling point-and-click workflow creation — and people can even build automated processes related to data outside of Salesforce. These features save time and let workers reduce the number of manual tasks they have to do. NetSuite users can try SuiteFlow, which works similarly to what Salesforce offers. When people set it up, they can based on their schedules or user-driven events. Relevant users will also get notifications within NetSuite or their email inboxes when any processes need manual intervention. Those real-time updates prevent errors from potentially interfering with someone’s productivity. create various flexible triggers Connecting operational data with workflow events and optimizing repeated tasks is also possible through SuiteFlow. Then, people throughout the organization can become more efficient. If users have issues with individuals frequently filling out forms incorrectly and interfering with data integrity, NetSuite has a solution for that, too. People can set up form-based parameters that catch errors and won’t let form submissions happen unless they meet specific criteria. This tool helps people make the most of their work because they don’t need to go back and correct mistakes later. Is Salesforce or NetSuite Better? There’s no universal answer regarding whether a person should choose NetSuite or Salesforce. Making the right decision requires taking the time to understand what each product can do and how the specific features would support an individual or company-wide workflow. Similar to how Salesforce offers complimentary trials, NetSuite provides product tours. Resources like those can reduce the learning curve associated with getting to know any new platform and help people envision how the solution would make life easier for them. Finally, people should come up with lists of questions to ask salespeople before making a final decision. Making those queries as specific as possible to a person’s business and needs will make the responses most relevant and helpful. Utilizing Salesforce vs. NetSuite When using one or the other, it’s essential to compare what each product can do versus company necessities. As workers get to know these products through direct experience, it’ll become clearer whether one aligns better with their needs and expectations. In any case, remember it usually takes time to learn the tricks and tips that help employees have the best possible outcomes. If they find they don’t like one of them as much as they’d hoped, time and patience may change their mind.

Salesforce vs. NetSuite

Companies implementing Salesforce’s built-in security solutions may find their customizations limit visibility into the risks that can impact other processes and applications. These complications often go unaddressed due to the idea that, since the platform includes those measures, security is its exclusive domain. However, the truth is that cybersecurity is a shared responsibility. Many of Salesforce’s vulnerabilities are . The Salesforce platform alone can’t fully protect users from their actions — companies must make ongoing efforts to help secure their cloud applications. a result of user customizations Here are four common Salesforce vulnerabilities to keep in mind. They show why it’s vital to find ways to optimize your company’s security. 1. Unsafe Authorizations Customizing authorizations in Salesforce can result in users with unsafe permission settings. This could leave your company vulnerable to internal or external cybercriminals and cause potential compliance issues. A single user may be able to modify access permissions for other people or even export sensitive data. You can close this security gap by replacing standing authorizations with . Here are two to consider: a more restricted security model Just-in-time model: The JIT model grants users system or application access as they need it. You can implement this method with privileged access management (PAM) software that will grant temporary access at users’ requests. Zero trust model: A zero trust model requires authentication from all users before they can access data or applications. Adopting this method means limiting everyone to the minimum access they need to perform their jobs and regularly validating their security status. It requires implementing technologies like multifactor authentication and identity-based segmentation. 2. Too Many Privileges Users with excess privileges can represent a similar security risk. Many companies delegate their Salesforce upkeep to a single administrator with a basic development staff for support. However, the access this person would need gives them almost unlimited power. They — or someone with their credentials — could purge vital data, create a new user with similarly elevated privileges and access reports with sensitive customer information. It’s crucial to avoid giving a single user too many permissions to prevent a situation like this, even if you think you can trust them. Even the most trustworthy employee can make costly mistakes. You can divide Salesforce management responsibilities across a department or hire a managed services team. 3. Improper Security Configurations Salesforce’s security customization options mean companies can accidentally create holes in their defenses. Misconfiguring may give a cybercriminal an opening to access customer data on your servers or upload malware by hijacking users’ sessions. Prevent this potential vulnerability by configuring your security framework according to best practices. Ensure that you’ve set it with: Multifactor authentication HTTPS encryption Minimum password lengths Appropriate sharing defaults and user permissions 4. Compromised System Integrations Salesforce’s flexibility sometimes makes it challenging to maintain full visibility, which can become a liability during system integrations. Improperly integrated third-party networks can create security gaps, leaving Salesforce vulnerable to external systems and giving hackers the chance to intercept communications. It’s vital to manage integrations according to security best practices to reduce the risk of hackers accessing Salesforce through compromised third-party applications. You should ensure your access and authorization configurations and APIs are secure. You can also use tools like Metazoa Snapshot that . Reviewing reports during the change and testing stages lets you double-check the process when integrating something new. document your change and release process Optimize Your Salesforce Security Four of the most common causes of Salesforce security vulnerabilities — unsafe authorizations, excessive privileges, improper security configurations and compromised system integrations — stem from user customizations. Salesforce offers various services and security options, but it’s up to users to implement them safely by ensuring compliance and following best practices.

How to Optimize Your Salesforce Security

Cómo optimizar su seguridad de Salesforce

Comment optimiser votre sécurité Salesforce

अपनी सेल्सफोर्स सुरक्षा का अनुकूलन कैसे करें

Salesforce セキュリティを最適化する方法

Como otimizar a segurança do Salesforce

Cách tối ưu hóa bảo mật cho lực lượng bán hàng của bạn

如何优化您的 Salesforce 安全性

When you look at the listings of the most popular Salesforce apps, those that have to do with document creation in one way or another are firmly featured. Often, DocuSign seems to take the top spot, promising smooth preparing, signing, acting on and managing contracts seamlessly within Salesforce. While the results in different listings depend on who is speaking, the top 15 usually include also document automation (Conga) and workflow creation (Nintex) tools, document collaboration (Quip) and email automation (Mailchimp) apps – possibly along with other electronic signature apps (AdobeSign). . Mind you, these days it is not just about sales but offers services also to marketing, customer success and service teams. Anybody working directly with customers seems to be well served in industries that range from health and life science and HR to financial services and manufacturing. , boasts seemingly an app for any purpose you might imagine. Most of them work across many of its various ‘clouds’ for different professionals. Salesforce is nothing less than the world’s leading customer relationship management (CRM) platform AppExchange, the Salesforce app store The popularity of document-related apps with Salesforce users certainly says something about their usefulness. But what makes them so popular? The answer is, there is not one but a few reasons. Let me walk you through the most important ones. Kill routines before they kill you - automate Let us suppose you are making an offer to a customer. You copy-paste sections from an old document to a new one. You copy customer and product data from your CRM or spreadsheets. Then you correct the layout where it has got broken… With many document types, many tasks are repeated in a quite identical way for each new document. The content stays the same while often just the transaction-specific details change. Creating each new document is time-consuming and boring, so could this be helped? A document automation app allows you to create a new document with accurate data with a click of a button. It speeds up the creation of these documents fundamentally. As an extra bonus, it eliminates human errors. The biggest relief for you as the author, however, is that much repetitive work is eliminated. You can use the time saved for more strategic, creative and fulfilling things, like planning out-of-the-box sales tactics, while refreshing yourself with an extra cup of coffee. As a salesperson, what are you getting paid for – writing a document or getting it signed and closing a deal? As a rule, document automation is based on standardized templates. Now, is this a little limiting, you may ask, since there are now and then exceptional requests from exceptional prospects, which require exceptional responses – and documents? Worry not. The templates of any good document automation app allow leaving sections free for editing. Also, libraries of prewritten clauses – alternative text sections to choose from - are usually supported. All in all, document automation makes things much smoother, since it: makes document creation easier, less boring and more motivating frees up time for more productive work: doing more business and spending more time with customers, for instance eliminates human mistakes adds agility to processes ensures the conformity of the documents. Tired of herding cats? Digitalize your workflow Creating those quotations, statements of work and contracts is a matter of pulling different types of content into a single document. Usually, there are many contributions: a number of authors, reviewers and approvers. When collaborating, they often have different interests that may conflict. Take the creation of a sales contract: the salesperson wants it to pass on to the signing quickly and get one deal closer to fulfilling their quota. Meanwhile, the lawyer wants to ensure the terms and conditions are water-tight to minimize risks. And the CEO wants to secure maximal returns from the deal and customer relationship. In the midst of it all, somebody has to see through that the contract passes all the necessary steps to fulfill everybody’s needs – definitely also the customers’. Contributions need to be collected from everyone involved. Differences in opinion need to be mediated. And finally, the all-important signatures must be collected from the approvers – who tend to be busy and hard to reach. To run all these nitty-gritty tasks – chasing the people, alerting them to their tasks and making the contract available for them to work on – many document automation apps offer automated workflows. So the app will do the heavy lifting when you, as the project manager, can focus on the content and people issues to ensure the best result for everybody. According to Gartner, no less than by 2025. Imagine doing such work of hearding cats online, just manually… Sounds like a really, really tall order! 80% of B2B sales interactions between suppliers and buyers will occur in digital channels Again, a lot of valuable time and effort can be saved with this technology. There is the saying “time kills all deals”. With well-planned workflows, chances are much better for you to keep your deals alive – and secure some more business and revenue. So let me recap the key benefits of implementing automated workflows. They: reduce time spent on human process management radically accelerate document turnaround and make the processes repeatable and uniform give the contributors a clear idea of their responsibilities improve process management by giving a better overview of it. Break out of the straitjacket – collaborate But what if a one-size-fits-all approach to automation does not suit you at all? After all, this is how it is for many companies with their business contracts. They must be individually tailored – even when a content template can be used as a starting point. Stringent negotiations are often needed on the terms of the contracts between many contributors on either side of the negotiation table. A recent Gartner study found that on average, . there are close to eight people on a seller's and close to six on a buyer’s side They usually come from different teams – sales, customer success & support, legal, management, even from several companies, to perform a series of tasks: defining the terms of the deal, filling in data points, checking legal wordings, revising the deal content and so forth. Document collaboration apps allow people to work together seamlessly online in the cloud – never leaving their Salesforce, regardless of their physical location. A company’s external participants, including customers, of course, can be included as easily as internal people. This comes as a great help since online is poised to be the future of customer relationships. A Salesforce study found that . customers anticipate engaging online with companies after the COVID pandemic as they have done during it A collaboration app can be quite simple to operate. You just need to upload an initial contract draft to Salesforce. Then you can create a no-code workflow using a visual workflow designer tool - or even choose a ready-made one - which will bring in all participants to work on the project. At the heart of such a solution is a collaboration space where everybody can add their contributions. A good collaboration solution allows version control, redlining, and commenting (even with selected visibility to just certain participants), all working in real-time on the display in front of your eyes, just like in the best document editing tools. In the course of the project, the contract draft will pass automatically from one contributor to another in a set order – like it does in a document automation workflow. Each participant is automatically reminded of a task when it needs to be done. For example, one collaborator is alerted to add the pricing information, then another one to check the delivery conditions, and yet another to look at, say, any additional services that may come in vital. All the while, as this happens on your side as the seller, the representatives on the customer side can make their additions, changes and comments – managed by the same workflow. And when all is ready and accepted, the workflow forwards the contract to the approvers and collects their e-signatures. Your document is ready. In essence, the collaboration app: calls all contributors together to collaborate smoothly keeps them up to speed and alerted to their tasks helps streamline processes, spot hiccups and correct them keeps everybody, especially the managers, on the map about how the collaboration projects work in general, through project dashboards and logs. The last point above is a surprisingly vital one. Harvard Business Review, for example, found recently that – that is, online. A good document collaboration app can ease this pain when it comes to group work on documents. 40% of managers struggle managing workers remotely Are you working in the chaos of applications? Clear it Not long ago, a study by Gensler Research Institute found . On the same note, according to a Lucidspark report, when work got remote. Microsoft, in turn, found that online . 55% of the respondents saying that collaborating with others is harder at home, than online 75% of remote online employees said that team collaboration was the activity that suffered the most remote work decreases cross-group collaboration by around 25% compared to on-premises What I have found is that much of the trouble remote workers experience comes down to how many tools they need to use. Those are so many, the most obvious ones being a word processor, email, messaging, spreadsheets, CRM, video conferencing app and so forth. On top of it all, everybody has their favorite brand. These apps do not work well with each other; integrations tend to be weak. A good Salesforce app can combine advanced document collaboration, cutting-edge workflows, and flexible automation – in one solution tailored to customers’ needs. With each task they do, the collaborators are given those tools they need, embedded right in the familiar Salesforce user interface. There is also the question of security. For example, the extended MS Office 365 environment has been increasingly targeted by cybercriminals in targeted phishing attacks. Cybercriminals can also target businesses’ digital systems by attacking the software vendors that deliver them, as aptly demonstrated by the past SolarWinds and Kaseya breaches. With each new tool you add, your risks increase; the fewer you use, the lower your risk of cyberattacks. Moreover, the advanced Salesforce document apps ensure data processing in compliance with the EU’s GDPR legislation on the data privacy of individual people. Mind you, GDPR compliance is a prerequisite for any company that does business globally, no matter whether based in the EU or not – especially as other regions have similar legislation, too. Putting effort into ensuring security pays: McKinsey has found, for instance, that if they had concerns about its security practices. 87% of customers would not do business with a company Overall, by relying on fewer, better-integrated applications out of the Salesforce AppExchange, you can: avoid jumping between applications enjoy functionality better tailored to each task at hand work wherever, whenever you like maintain a smaller set of tools for all your staff company avoid cyber attacks, compliance issues and excessive strain on IT support. It is not ready before it is approved. Seal it with a signature Electronic signature apps for Salesforce may come in stand-alone versions or ones readily integrated into the automation, collaboration, and/or workflow apps I discussed before. When connected to the document workflows, they automate most of the approval and signing of documents – in compliance with standards like eIDAS by the European Union. They make approvals easy for the approvers, who tend to be busy people. Usually signing a document takes just a few clicks via actionable alerts. This reduces the document turnaround time radically – and saves a lot of work from those chasing the approvals. Once ready, a copy of a signed document can be automatically delivered via email to anybody who needs it. For future use, all business documents can usually be stored in a single place, for example in Salesforce files. From then on, the latest version will always be easily available for those who need it. By deploying an electronic signature app, you can achieve: compliance with standards such as eIDAS by the EU quick, smooth signing of documents automated delivery and archiving of signed documents making documents available right in the context they are used at - Salesforce. Conclusion Apps created for document processing come in many types: electronic signature, collaboration, document automation, workflow automation, and email automation apps – , like with Documill Ltd. They are clearly the darlings of Salesforce users. sometimes even in an all-in-one solution And why not? After all, whatever the activity is taking place between a supplier and a customer, it needs to be documented properly – be it offering a service or product, making a deal, aftersales or customer support. Creating documents makes a big chunk of the work you need to do when cultivating your customer relationships. It certainly pays to invest time, money, and effort in making it as smooth, safe, and controlled as possible. And this is just what the Salesforce document apps were created for.

Why are Document Creation Apps the Darlings of Salesforce Users

For the last time of the year, the Salesforce ecosystem is buzzing with enthusiasm as winter and spring approach. The start of a new year brings new chances to make an impact. You need more unique features and upgrades to look forward to from Salesforce Partners, particularly Salesforce Admins. Whether you are a Salesforce user, you need to search for features to simplify your job or a consultant, administrator, or developer. They may look for methods to give the best possible end-user experience and each version has something for everyone. helps you to gather the information you will need to get ready for the next software changes in one article: Salesforce development Say goodbye to checkout and hello to your account app: With the Sales force's brand-new self-service solution, the Your Account app can manage your subscriptions and purchase new licenses on your own. This feature has superseded Salesforce Checkout. A new landing page exposes you to the Your Account app when you navigate the Checkout page in Salesforce setup. You can travel to the Your Account app or learn by selecting the Your Account option. Explore for knowledge reports registered in numerous languages: Einstein at no additional expense, Search improves your organization's search experience. You can search articles written in various languages in the Knowledge database. It will greatly simplify the lives of service agents all across the world. Search looks for pieces that match the words in an agent's query and provides the ones. Custom Salesforce Development will build in their profile language and the Knowledge base default language. An agent can change the Knowledge language filter to add languages or override the defaults. For all the languages chosen, Search returns relevant results. The global search box and the Knowledge search sidebar are the only places you can search in more than one language. Obtain Tableau CRM and Data Pipelines Data Together: You can combine data from Tableau CRM and Data Pipelines to avoid repeating Tableau CRM recipes in Data Pipelines to generate the same information. You can choose which product's restrictions a recipe's run and dataset will utilize if you are utilizing both of these products. To prevent having to recreate and update recipes in both products, use the inputs from either product when constructing recipes. In Lightning, you can choose from a variety of report types. The flow of creating a report has been updated and improved. When writing an account, you don't have to guess which report type will be most useful. Salesforce Customization enables you to rapidly access frequently used reports and inspect the fields and objects. You can tell the difference between standard and custom reports kind. To reduce clutter, you can conceal report types that are rarely utilized. Edit numerous Fields Inline on the Declaration Run Page: You wouldn't believe it if they told you that tabular reports act like object list views with inline editing. You can update many records at once using inline editing on the Report Run page. It doesn't matter if the modifications are in numerous rows or columns. You just need to hit save once you are finished to save everything. It is a great approach to keep several statuses up to date or tidy up data without rebuilding your report. Manage Expiration dates with an Enhanced User Experience: The setup page for permission sets and permission set groups has been updated. To give permission sets and permission set groups to users in your org, you can quickly search for and filter them. You can better control the expiration dates with the new Lightning list views. This is particularly useful when working on projects with deadlines. You can specify a permission set or permission set group's expiration date to coincide with the project's end date and construct a filter for a certain set of users who are part of that project. Orchestrate Multiuser Processes with Flow Orchestrator: You can consolidate all of your automated processes in one place with Flow Orchestrator. Orchestrator's no-code method allows you to arrange and transform Flows into stages. You need , and they will apply a strategy for offering numerous advantages. Certified salesforce developers It may also include increased flexibility when creating approval procedures, improved ability to allocate tasks to any Salesforce user, and greater control over record lifecycles. Use Flow Orchestrator to automate complex operations, and order your Record-Triggered Flows with Flow Trigger Explorer. Increase Productivity with Orchestrator Work Guide: Orchestrator Work Guide is a new Lightning Component with the Orchestrator feature. It displays notifications when Orchestrator operations progress once you have added it to your Lightning pages. The orchestrator creates a work item for the next assignee and displays a notification in the Work Guide component when the work is ready for the next assignee. Without switching contexts, the allocated user may easily examine and complete work on the appropriate record. Monitor Your Slowest Desktop Record Pages: Salesforce Lightning Experience provides end-users with a rich and intuitive user experience, but the Lightning pages take longer to load in the browser. To address this, Salesforce included a capability in prior editions that allowed users to analyze the performance of Lightning pages. You have to hire salesforce API developers who have prompt knowledge of lightning pages. They will provide you with a list of desktop record pages with an EPT of 4 seconds or longer. Analyze such pages and make changes to improve their performance. Say Hello to the Digital Experience App in Lightning Experience: The Salesforce CMS app has been renamed Digital Experiences because it includes settings that aren't related to CMS. The name convention has also been updated to reflect the Digital Experiences setup menu. In addition to editing your CMS content, you can use this app to see the details of your site and the underlying foundation it employs. Your website can also be archived using this application. Experience a more efficient collaborative Forecasts setup: The Salesforce setup page for collaborative forecasts has been redesigned. Forecast Types and Settings are now on the same page, so you don't have to switch between pages to configure them. If you get lost, you will discover several useful links on the same page to learn more about Collaborative Forecasts. It is only available in Lightning Experience. Final thoughts: The significant developments from the Sales force's spring announcement are summarized here. They encourage you to become comfortable with all of these tools, use Trailhead GO to continue studying, and not be afraid to embrace and learn about Salesforce solutions. It is a platform that will greatly facilitate the expansion of your project.

11 Fascinating Features Salesforce is Releasing in 2022

They say this is a Bear market but I've seen two announcements this week that actually mean more than any other Web3 VC funding press release. PayPal is finally offering a long-demanded feature that will let users move their crypto to external wallets and hardware devices. PayPal first launched its crypto offering in late 2020, allowing users to buy, sell, and hold four cryptocurrencies—Bitcoin, Ethereum, Bitcoin Cash, and Litecoin—but not to move the funds to external destinations like MetaMask, Coinbase, or hardware wallets. The fact users now can do this is significant because PayPal, which also owns the popular app Venmo, is used by hundreds of millions of people across the world to move money, and is increasingly used by merchants as a payment platform. And today (per the previous post) Salesforce has announced their new NFT minting cloud platform. NFT Cloud is billed as an easy-to-use step into the world of NFTs and the budding metaverse, allowing brands to tap Salesforce’s cloud-based tools to build and sell NFTs, engage online communities, and pull data from their offerings. can do. Adam Caplan, Salesforce’s Senior Vice President of Emerging Technology, said that brands are more likely to use NFTs for engagement and reach – rather than selling collectibles without functional utility. (1) (2) What does that actually mean then? As of the end of 2021, there are 426 million active users on PayPal worldwide, and 2.5m users of Venly. Salesforce has 150,000 customers, is billed as the World's #1 CRM platform and boasts Fortune 500 clients. That sleeping giant called Web2 is actually doing more to onboard people onto the promise of Web3 while everyone is arguing over whether play-to-earn is the future or not. Plus there's another factor to consider - companies like Salesforce delivering an easy-to-use and sustainable NFT minting cloud platform are more likely to resolve the issue of interoperability first outside of games, and with clients like Mercedes Benz, ADIDAS, PayPal (yes, them!) and AT&T that's real consumer traction and reach startups can only talk about achieving in their Discord chatter. Imagine being able to swap and use your ADIDAS NFTs with a Mercedes loyalty program? That goes well beyond what is being touted as 'utility' today elsewhere. This might be a Bear market for crypto but both PayPal and Salesforce have shown that this industry is already hibernating when it comes to really pushing forward towards mass adoption.

Salesforce NFT Cloud is Doing More for Web3 than Web3 startups

The fundamental capabilities of the internet can be boiled down to one simple interaction: a call and a response. One machine (the client) sends to another machine (the server), which with a reply. This back-and-forth request-and-response cycle is how every phone, television, smart fridge, or computer sends and receives data. requests responds However, there are several security risks inherent in this model, from application vulnerabilities to DDoS attacks. In this post, we’ll take a closer look at how Cross-Origin Resource Sharing, or , mitigates these risks and how it operates. By working with a small Node.js app that interacts with several Salesforce APIs, we will see the differences in responses when CORS is enabled and disabled, as well as what effect it has on our client. CORS First, let’s take a deeper look at what CORS is and why it exists. Web Pages Call External Resources Whenever a browser requests a web page, the server sends back a chunk of HTML. The browser then draws that HTML and, crucially, continues to ask the server for more information when necessary. For example, if there’s any content that can’t be parsed, such as images or videos, or code that needs to be executed (such as JavaScript), then the browser continues making requests to the server, and the server happily fulfills them. Security Risks Suppose you’re browsing around at , and your browser encounters some JavaScript that executes a request to . For example, say a piece of code wants to get a list of a user’s completed trails using the API: salesforce.com trailhead.com fetch let response = await fetch('https://api.trailhead.com/user/1/trails'); On the surface, this JavaScript code is pretty innocuous, but it presents a fundamental question about how the web operates: If a browser is loading , should it also be able to load data from ? One’s instinct might be to say, “Yes, of course.” But if we allow to load from , why not allow loading code from , , or ? Why not just load code from anywhere? salesforce.com trailhead.com salesforce.com trailhead.com heroku.com github.com google.com Walking the slippery slope of making requests from any site in the world also introduces the security risks mentioned above. In this example, without any boundaries, can’t control who is requesting data from them. What would be is if a server could make a list of whom it trusts to be given access out on the web. Perhaps will allow users on to load scripts, but not from anywhere else. trailhead.com ideal trailhead.com salesforce.com Enter CORS! CORS is designed to plug this hole. A server dictates not only which domains can access its resources, but the types of HTTP verbs as well. If a client isn’t able to satisfy the server’s CORS requirements, then data cannot be executed or delivered. CORS is a concept that extends beyond any one programming language and is configured on a web server, such as nginx or Apache. Most crucially, it’s enforced by the browser: there’s no way around it, and data enforced by CORS can’t be accessed by browser clients outside of that context. CORS is designed to walk the line between enabling a client’s productivity and enforcing a server’s security. CORS is enforced through , which can be thought of as additional metadata attached to HTTP requests and responses. You might be familiar with adding headers for (such as ) or to specify the data types the client understands (via ). CORS has , which a server uses to state where a browser may load its resources from. HTTP Headers authentication Authorization: token xxx Accept its own category of headers To demonstrate what this means in practice, let’s take a look at how a demo app using the Salesforce platform interacts with CORS. Demo prerequisites Before getting started, make sure that your . If you don’t have access to the Salesforce platform, then you can . You can use this org to test what developing on the Salesforce platform looks like. Salesforce instance supports access to its API create a free Developer Edition account Requesting Salesforce resources Open a browser tab and navigate to . In the box that says JavaScript, paste these lines of code: https://jsfiddle.net const run = async () => {
const response = await fetch('https://myInstance-dev-ed.my.salesforce.com/services/data');
const responseJson = await response.json();
responseJson.forEach( (e) => document.write(e.label + "<br/>"));
document.body.style.background = "white";
}
run(); Replace with the actual name of your Salesforce instance. Click in the top menu bar. You should see….nothing. myInstance-dev-ed Run However, if you open , you’ll see a message indicating that CORS has blocked access: the Browser Console Access to fetch at 
'https://myInstance-dev-ed.my.salesforce.com/services/data' from origin 
'https://fiddle.jshell.net' has been blocked by CORS policy: No 
'Access-Control-Allow-Origin' header is present on the requested resource. 
If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled. What’s going on here? Well, Salesforce provides semi-open access to its data and assets. In this case, we tried to use JavaScript’s function to make a request and retrieve some JSON data. However, due to CORS, we were blocked from doing so. Unauthorized access is exactly what CORS was designed to prevent. fetch Specifically, we were blocked by the lack of a proper definition. This header states which URLs a browser is permitted to load resources from. If this information is missing, then the browser simply cannot load the external resource, which in this case was the content at the path of our Salesforce instance. There are many other types of CORS headers, such as , which defines which HTTP methods a browser is permitted to make. Access-Control-Allow-Origin /services/data Access-Control-Allow-Methods Enabling CORS in Salesforce Fortunately, it doesn’t take much to enable CORS on the Salesforce APIs. Follow the short steps , and enter as the allowed domain: in this guide https://fiddle.jshell.net Make sure there’s no trailing slash at the end of this URL. Click , then run that code snippet one more time. Voila! It’s not much, but you should see a list of some Salesforce editions. Save Other CORS Considerations While Salesforce takes the utmost effort to provide a way to securely retrieve data, other platforms might not be as secure. Fortunately, CORS also provides the ability to pass in credentials . Credentials are useful if you’re navigating on a site that, unlike Salesforce, does not use an authentication mechanism. By setting an additional option in your client-side JavaScript request ( ), your browser’s cookies are sent over along with the request. Cookies have been used as an identifying mechanism since the very early days of the internet. Although they’ve largely been abandoned as an authentication method, some websites still do use them as such. It’s the server’s responsibility to receive the cookies and perform any additional validations on them. credentials: "include" Since CORS support is largely a consideration for servers (that is, servers should have CORS enabled by default), there isn’t much else for the client to do. There are different that a client can set, which have a variety of purposes. For example, if you’re building a series of microservices, then you may find that the ’s strict domain matching may be useful for doubly ensuring that requests and responses come from the same domain. modes same-origin We’ve largely been talking about CORS and JavaScript, but there’s another important component to web development where CORS can step in: the humble . The iframe element allows you to embed the contents from another URL into a web page. What keeps me from registering and just setting the page to the contents of Salesforce? CORS, of course! <iframe> www.not-salesforce.com Conclusion Ultimately, not every server supports open CORS access, and it’s at the server’s discretion. Improperly configured CORS settings have the potential to impede legitimate user workflows, but disabling CORS entirely will certainly make your application more vulnerable to attacks from malicious clients. In general, as a developer, if an action can be done on the server, it’s more likely to be safer than performing work on the client, so make sure you are disabling CORS for a good reason if you’re thinking of it. We’ve just taken a brief look at Salesforce APIs here. You can also manipulate data or retrieve all sorts of Apex data. We encourage you to take a look at for more information on what the APIs allow you to do. You can also find to help you build your integrations with the platform. the Force.com REST API Developer Guide a bevy of tutorials on Trailhead

Working with Salesforce APIs? Of CORS!

Last year, my wife and I gained the first-time experience of building a brand-new home. The process was fun and exciting, but we also experienced the unexpected internet service interruptions that often accompany new home subdivisions. While these outages impacted my family’s ability to stream services, such as Amazon Prime, Hulu, and Netflix, I continued working on my current project, due to the intentional design of being able to work in an isolated (or offline) state. This has always been helpful during airline travel when I work from Nevada and Florida during the year. This made me wonder why more mobile apps are not designed to continue working during internet service interruptions. In this publication, I will demonstrate just how easy it is to make your mobile app usable in offline mode. Since I recently spent time with the , I wanted to continue exploring that mobile app option. Salesforce Mobile SDK Working Offline with Salesforce Mobile SDK Before we get into writing code, let’s touch briefly on how offline functionality works with the Salesforce Mobile SDK. The left side of the illustration presents the traditional manner in which the Salesforce application is utilized. The right side provides a high-level overview of the Salesforce Mobile SDK. Native applications that run on Android or iOS devices can be written in Android Studio, Xcode, or React Native. Those applications include the user interface, some level of business logic, and model objects representing elements that ultimately live in Salesforce. The Salesforce Mobile SDK includes a SmartStore aspect, which makes data available when the mobile application cannot access the Salesforce service. The model layer can be easily designed to leverage the SmartStore when offline mode is required (or preferred), but ready to synchronize all changes with Salesforce when online status is available. If you want to read more about this design, check out “ .” Using SmartStore to Securely Store Offline Data Adding Offline-ability to Finny’s Foods Earlier this year, I explored the Salesforce Mobile SDK and created a fictional app called Finny’s Foods. I created the app three times using Android, iOS, and React Native. I thought I would start from the that used the iOS/xCode (Swift) version of the Salesforce Mobile SDK, then build upon it to provide offline functionality. publication The GitLab repository for the original article is listed below: https://gitlab.com/johnjvester/finnys-foods-ios The first step is to establish the object in the file that is used by the SmartStore functionality. Meal__c userstore.json {
  "soups": [
    {
      "soupName": "Meal__c",
      "indexes": [
        { "path": "Id", "type": "string"},
        { "path": "Name", "type": "string"},
        { "path": "Rating__c", "type": "integer"},
        { "path": "__local__", "type": "string"}
      ]
    }
  ]
} Next, update the file to make the current list of meals available offline: usersyncs.json {
  "syncs": [
    {
      "syncName": "syncDownMeals",
      "syncType": "syncDown",
      "soupName": "Meal__c",
      "target": {"type": "soql", "query":"SELECT Id, Name, Rating__c FROM Meal__c ORDER BY Name ASC"},
      "options": {"fieldlist":["Id", "Name", "Rating__c", "LastModifiedDate"], "mergeMode":"LEAVE_IF_CHANGED"}
    }
  ]
} You can read all about the SmartStore sync configuration in “ .” Registering Soups with Configuration Files With the SmartStore configuration in place, I refactored the class as shown below: MealsListModel.swift class MealsListModel: ObservableObject {
    
    @Published var meals: [Meal] = []
    
    var store: SmartStore?
    var syncManager: SyncManager?
    private var syncTaskCancellable: AnyCancellable?
    private var storeTaskCancellable: AnyCancellable?
    
    init() {
         store = SmartStore.shared(withName: SmartStore.defaultStoreName)
         syncManager = SyncManager.sharedInstance(store: store!)
    }
     
    func fetchMeals(){
         syncTaskCancellable = syncManager?.publisher(for: "syncDownMeals")
             .receive(on: RunLoop.main)
             .sink(receiveCompletion: { _ in }, receiveValue: { _ in
                 self.loadFromSmartStore()
         })
         self.loadFromSmartStore()
     }
     
     private func loadFromSmartStore() {
          storeTaskCancellable = self.store?.publisher(for: "select {Meal__c:Id}, {Meal__c:Name}, {Meal__c:Rating__c} from {Meal__c}")
             .receive(on: RunLoop.main)
             .tryMap {
                 $0.map { (row) -> Meal in
                     let r = row as! [String?]
                     return Meal(id: r[0] ?? "", Name: r[1] ?? "", Rating__c: (r[2]! as NSString).doubleValue)
                 }
             }
             .catch { error -> Just<[Meal]> in
                 print(error)
                 return Just([Meal]())
             }
             .assign(to: \MealsListModel.meals, on:self)
     }
} I updated the function to interact with the SmartStore by default, calling Salesforce when needed but allowing data stored in the application to be used if the device is in offline mode. fetchMeals() Believe it or not, that’s all that is required. Finny’s Foods in Offline Action After launching Finny’s Foods from XCode and an iPhone 8 emulator, we see the following screen displayed as it did in the original publication. Now, if I disconnect my device from the internet and reload the application, the following logs appear in XCode: 2022-03-14 16:14:15.544412-0400 FinnysFoodsIOS[88679:6546397] [MobileSync] CLASS: SFSyncDownTask runSync failed:{ ... } cause:Server call for sync down failed errorError Domain=NSURLErrorDomain Code=-1009 "The Internet connection appears to be offline." However, the application still loads and provides the data from the SmartStore. In fact, without looking at the logs in XCode, I would have had no idea that I was working with a local version of the data. For offline applications which allow data to be added or updated, the SmartStore has the ability to merge offline and online data with a Sync Manager. See the__ __ documentation for additional information. Syncing Data Conclusion Although internet connectivity continues to improve, a reliable connection is not 100% guaranteed. Forward-thinking feature developers should consider taking the appropriate steps to allow their apps to continue working when an internet connection is not available. Ask yourself: How can my app be better when working in a disconnected state? Since 2021, I have been trying to live by the following mission statement, which I feel can apply to any IT professional: ** ** “Focus your time on delivering features/functionality which extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” - J. Vester In this article, I provided an example of how easy it is to implement offline functionality using the Salesforce Mobile SDK. Salesforce engineering designed the integration point at the model layer, and that’s the best place to determine if live data can be retrieved or if SmartStore data should be returned. Clearly, Salesforce adheres to my personal mission statement by offering a design that is easy to employ without a great deal of boilerplate code. If you are interested in the source code for this article, you can find it on GitLab here: https://gitlab.com/johnjvester/finnys-foods-ios Have a really great day!

Stories, News & Mentions about SALESFORCE

Salesforce’s Stories on HackerNoon

Salesforce's News & Mentions