Hello Trailblazers!

Salesforce Reports are a powerful way to analyze data, and one of their most useful features is the Bucket Field. This tool allows you to group report data into categories without creating custom fields or formula fields in your Salesforce objects. Whether you’re working with large datasets or need a quick way to analyze trends, bucket field can save time and streamline your reporting.

In this blog, we’ll learn what is Bucket field in Salesforce is and how to create it, along with its benefits and limitations.

So let’s get started…

Before you Begin:

In the earlier parts of this Salesforce Reports blog series, we explored the fundamentals of Salesforce Reports, including their types, how to create them, and several key aspects surrounding them. I highly recommend reviewing those previous posts using the provided links for a better understanding before diving into this section.

What is a Bucket Field in Salesforce?

A Bucket Field is a feature in Salesforce Reports that lets you group report records based on criteria you define. Instead of modifying your Salesforce schema to create custom fields, you can categorize records dynamically within the report.

For example:

• Group revenue/Profit into “High,” “Medium,” and “Low” categories.
• Classify accounts based on annual revenue ranges.
• Organize leads by age groups.

Benefits of Using Bucket Fields

1. No Schema Changes: Avoid altering the underlying Salesforce object structure.
2. Dynamic Categorization: Adjust categories directly in the report as needed.
3. Simplified Analysis: Focus on trends without extensive pre-processing.
4. Flexibility: Combine values from multiple fields into a single category.

Limitations of Bucket Fields

1. Static Configuration: Categories are hardcoded into the report and don’t update dynamically.
2. Field Limits: A report can have up to 5 bucket fields, and each bucket field can contain up to 20 buckets.
3. Availability: Bucket fields are only available in tabular, summary, and matrix reports.

Note: To explore more about the limitations of Bucket Fields, please refer to the link provided under the “Related Posts” section.

Steps to Create a Bucket Field in Salesforce Reports

Follow these steps to create and use a Bucket Field in your Salesforce report:

Step 1: Create or Open a Report

1. Navigate to the Reports tab in Salesforce.
2. Click on New Report or open an existing report.
3. Select the report type (e.g., Accounts, Opportunities).
4. Here we are selecting the “Opportunities” report type as shown in the figure below.

Step 2: Add a Bucket Field

There are two methods to add Bucket Fields/Column into the report.

Method 1 –

1. In the report builder, click Outline in the left-hand panel and go to the Columns.
2. Click on the dropdown menu next to Columns.
3. Select Add Bucket Column as shown in the figure below.
4. One more step – Once you click, a pop-up will open, there you need to select ‘Field’ for the bucket column.

Method 2-

1. Open the Report Builder and navigate to the field you want to create a bucket column for. In this example, we’ll create a bucket column for the “Amount” field.
2. Click the dropdown menu located next to the “Amount” field.
3. From the displayed options, select “Bucket this Column” as illustrated in the figure below.

These are the 2 methods to add bucket fields into the report.

So, we will move forward with the Method 2.

Step 3: Configure the Bucket Field

Once you select the ‘Bucket this Column’ as illustrated above, a popup will open to the edit bucket column.

1. Name Your Bucket Field: Enter a descriptive name (e.g., “Profit Category”).
2. Select a Source Field: Choose the field you want to bucket (e.g., Amount). (It will be auto-selected if you go with Method 2)
3. Define Bucket Criteria:
   • Enter a name for the bucket (e.g., “Low Profit”).
   • Set Values/Ranges for each Bucket.
   • Click Add to create new buckets like Medium Profit, High Profit, etc. by defining their respective criteria of Amount.
4. Click Apply to save the bucket field configuration.

Step 4: Use the Bucket Field in Your Report

After creating the bucket column, Salesforce automatically adds it to your report. This new column functions like a formula, dynamically applying the defined criteria to each row of your report for streamlined data grouping and analysis.

1. Drag and drop the newly created bucket field anywhere as required into the report canvas.
2. Group, filter, or summarize data using the bucket field as needed.

To group your report data by Bucket field, follow the below steps:

1. Click on the dropdown menu next to the recently created bucket field – Profit Category.
2. Choose the option “Group Rows by this Field” from the menu, as demonstrated in the image below.
3. This action will summarize the report data based on the Bucket fields/column, and the resulting report will appear as shown below.

Step 5: Save and Run the Report

1. Save the report by clicking Save & Run.
2. Provide a name, description, and folder location for the report.
3. Click Save to view your categorized data.

Note: The bucket options available in the Edit Bucket Column menu vary based on the data type of the column you’re working with. Salesforce allows you to bucket three data types: numeric, picklist, and text, providing flexibility to categorize your data effectively.

Best Practices for Bucket Fields

1. Plan Categories Thoughtfully: Use meaningful names and criteria for buckets to ensure clarity.
2. Test with Sample Data: Verify that records are grouped correctly before finalizing the report.
3. Keep It Simple: Avoid overloading reports with too many bucket fields to maintain readability.
4. Document Configurations: Include descriptions for bucket fields to help collaborators understand the logic.

Use Cases for Bucket Fields

1. Sales Performance: Categorize opportunities by deal size.
2. Customer Segmentation: Group accounts by revenue tiers or industry types.
3. Lead Analysis: Classify leads based on lead source or age.
4. Trend Analysis: Break down data into time-based buckets for insights into seasonal patterns.

Conclusion

Bucket Fields in Salesforce Reports are an invaluable tool for categorizing data dynamically. They empower users to create flexible and insightful reports without making changes to Salesforce objects. By following the steps outlined in this blog, you can easily implement bucket fields in your reports and uncover actionable insights that drive better decision-making.

Happy Reading!

 “Positive affirmations are like seeds planted in the mind; with consistency and care, they grow into a garden of confidence, resilience, and self-belief.”

Related Posts:

1. Bucket Field in Salesforce
2. Bucket Field Limitations

You Can Also Read:

1. Introduction to the Salesforce Queues – Part 1
2. Mastering Salesforce Queues: A Step-by-Step Guide – Part 2
3. How to Assign Records to Salesforce Queue: A Complete Guide
4. An Introduction to Salesforce CPQ
5. Revolutionizing Customer Engagement: The Salesforce Einstein Chatbot

Salesforce has officially unveiled Agentforce 2.0, a groundbreaking update that redefines how enterprise AI solutions are developed, deployed, and managed. This new iteration introduces innovative features designed to streamline collaboration, enhance integration, and provide unmatched flexibility for building AI-powered workflows.

Agentforce 2.0 focuses on three primary advancements: headless agents for seamless programmatic control, advanced Slack integration for improved teamwork, and a revamped integration architecture that simplifies development and deployment processes.

Pic Courtesy: Salesforce

Core Highlights of Agentforce 2.0

1. Enhanced Integration Architecture

At the heart of Agentforce 2.0 is its sophisticated integration framework. The new system leverages MuleSoft for Flow, offering 40 pre-built connectors to integrate with various enterprise systems. Additionally, the API Catalog serves as a centralized hub for discovering and managing APIs within Salesforce, streamlining workflows for developers.

The Topic Center simplifies the deployment process by embedding Agentforce metadata directly into API design workflows, reducing manual configuration and accelerating development cycles.

Key features of the API Catalog include:

• Semantic descriptions for API functionalities
• Clear input/output patterns for APIs
• Configurable rate limiting and error handling
• Comprehensive data type mappings

This API-first approach centralizes agent management, empowering DevOps teams to oversee and optimize AI capabilities through a single interface.

2. Upgraded Atlas Reasoning Engine

The Atlas Reasoning Engine in Agentforce 2.0 delivers next-generation AI capabilities, making enterprise AI smarter and more effective. Enhanced features include:

• Metadata-enriched retrieval-augmented generation (RAG)
• Multi-step reasoning for tackling complex queries
• Real-time token streaming for faster responses
• Dynamic query reformulation for improved accuracy
• Inline citation tracking for better data traceability

Initial testing shows a 33% improvement in response accuracy and a doubling of relevance in complex scenarios compared to earlier AI models. The engine’s ability to balance rapid responses (System 1 reasoning) with deep analytical thinking (System 2 reasoning) sets a new standard for enterprise AI.

3. Headless Agents for Greater Control

One of the most transformative features is the introduction of headless agent deployment. These agents function autonomously without requiring direct user input, offering developers a new level of control.

Capabilities include:

• Event-driven activation through platform events
• Integration with Apex triggers and batch processes
• Autonomous workflows for background processing
• Multi-agent orchestration for complex tasks
• AI-powered automation of repetitive operations

This feature positions Agentforce 2.0 as an essential tool for enterprises looking to optimize their digital workforce.

4. Deep Slack Integration

Agentforce 2.0 brings AI directly into Slack, Salesforce’s collaboration platform, enabling teams to work more efficiently while maintaining strict security and compliance standards.

Technical advancements include:

• Real-time indexing of Slack messages and shared files
• Permission-based visibility for private and public channels
• Dynamic adjustments for shared workspaces and external collaborations

By embedding AI agents directly within Slack, organizations can eliminate silos and foster seamless collaboration across departments.

5. Data Cloud Integration

Agentforce 2.0 leverages Salesforce’s Data Cloud to enhance AI intelligence and data accessibility. This integration enables:

• A unified data model across systems for real-time insights
• Granular access controls to ensure data security
• Metadata-enriched chunking for RAG workflows
• Automatic data classification and semantic search capabilities

Final Thoughts

Agentforce 2.0 represents a bold step forward in enterprise AI development. By combining headless agent technology, deep Slack integration, and an advanced API-driven framework, Salesforce has created a platform that redefines how organizations leverage AI for business innovation.

The Salesforce Winter ’25 Release introduces a significant enhancement: the integration of Knowledge and Unified Knowledge with Data Cloud. This update is set to revolutionize how businesses manage and utilize their knowledge bases. How to leverage the power of Data Cloud to improve generative AI features for Einstein for Service. In this blog, we will explore the key features of this integration. We will explore the differences from previous versions, and practical examples of its application.

Pic Courtesy: Salesforce

Key Features of the Integration

1. Combining First and Third-Party Knowledge

   Data Cloud allows businesses to integrate both first-party (internal) and third-party (external) knowledge sources. This comprehensive approach ensures that all relevant information is accessible in one place, enhancing the quality and accuracy of AI-generated responses.

2. Retrieval-Augmented Generation (RAG) Updates

   The latest RAG updates in Data Cloud provide higher-quality replies and answers by grounding generative AI features in a broader and more diverse knowledge base. This results in more accurate and contextually relevant responses.

3. Increased Article Size Limit

   Previously, articles in Salesforce were limited to 131,000 characters in rich text fields. With Data Cloud, this limit has been significantly increased to 100 MB. However, articles exceeding 25 MB are not indexed for search, ensuring optimal performance and searchability.

4. Preparation for Future Enhancements

   To power the data integration capabilities of Unified Knowledge, Salesforce has partnered with Zoomin Software. Zoomin’s knowledge orchestration platform enables organizations to connect, harmonize, and deliver knowledge from any source to any touchpoint. Through this partnership, Salesforce customers can leverage Zoomin’s pre-built connectors and APIs to quickly integrate their enterprise data sources with Salesforce’s knowledge base.

5. Unified Knowledge with Zoomin

   Salesforce has partnered with Zoomin to offer Unified Knowledge, available as a free trial for 90 days. This feature includes three connector instances to third-party knowledge sources, providing a robust solution for integrating diverse knowledge bases.

6. Knowledge Article DMO

   With the Knowledge Article Data Management Object (DMO), businesses can access their knowledge base on Data Cloud. This infrastructure supports the size and scaling needs of enterprise customers, enabling the integration of transactional knowledge, such as Slack posts, alongside curated articles.

Differences from Previous Versions

The integration of Knowledge and Unified Knowledge with Data Cloud brings several notable improvements over previous versions:

• Article Size Limit

  The previous limit of 131,000 characters in rich text fields has been expanded to 100 MB, allowing for more comprehensive and detailed articles.

• Enhanced AI Features

  The switch to Data Cloud grounding and the latest RAG updates significantly improve the quality of AI-generated responses, providing more accurate and contextually relevant answers.

• Unified Knowledge

  The partnership with Zoomin introduces Unified Knowledge, offering a more integrated and cohesive knowledge management solution.

• Scalability and Infrastructure

  Data Cloud’s infrastructure supports larger and more complex knowledge bases, catering to the needs of enterprise customers.

Practical Example

Consider a customer service team using Salesforce to manage their knowledge base. Previously, the team was limited by the 131,000-character limit for articles, which restricted the amount of information they could include. With the new 100 MB limit, they can now create more detailed and comprehensive articles, improving the quality of information available to both agents and customers.

Additionally, the integration with Data Cloud allows the team to combine internal knowledge with third-party sources, providing a more holistic view of available information. The enhanced AI features ensure that generative AI tools like Einstein for Service can deliver more accurate and relevant responses, improving customer satisfaction and reducing resolution times.

How to Set Up

To integrate Knowledge and Unified Knowledge with Data Cloud, follow these steps:

1. In Data Cloud Setup, click Salesforce CRM.
2. Choose Standard Data Bundles.
3. Select Service Cloud and either Install or Update the latest version of the Service data kit.

Conclusion

The integration of Knowledge and Unified Knowledge with Data Cloud in Salesforce Winter ’25 Release is a game changer for businesses looking to enhance their knowledge management capabilities. By combining first and third-party knowledge, increasing article size limits, and leveraging advanced AI features, this update provides a robust and scalable solution for managing and utilizing knowledge bases. Whether you are a small business or a large enterprise, these enhancements will help you deliver better service and support to your customers.

The release of Salesforce Agentforce 2.0 introduces a powerful AI-driven architecture that transforms how enterprises build, deploy, and manage intelligent agents. However, leveraging these advanced capabilities requires a well-structured DevOps strategy.

Below are best practices for ensuring successful implementation and optimization of Agentforce 2.0.

Pic Courtesy: Salesforce

Best Practices for AgentForce 2.0

Below are best practices for ensuring successful implementation and optimization of Agentforce 2.0.

1. Version Control: Keep AI Configurations Organized

Managing the complexity of Agentforce 2.0 is easier with proper version control. DevOps teams should:

• Treat Agent Definitions as Code: Store agent definitions, skills, and configurations in a version-controlled repository to track changes and ensure consistent deployments.
• Skill Library Versioning: Maintain a version history for agent skill libraries, enabling rollback to earlier configurations if issues arise.
• API Catalog Versioning: Track updates to the API catalog, including metadata changes, to ensure agents remain compatible with system integrations.
• Permission Model Versioning: Maintain versioned records of permission models to simplify auditing and troubleshooting.

2. Deployment Strategies: Ensure Reliable Rollouts

With Agentforce 2.0’s advanced capabilities, deployment strategies must be robust and adaptable:

• Phased Rollouts by Capability: Gradually introduce new agent features or integrations to minimize disruption and allow for iterative testing.
• A/B Testing for Agent Behaviors: Use A/B testing to compare different configurations or skills, ensuring optimal agent performance before full deployment.
• Canary Deployments: Deploy new features to a small subset of users or agents first, monitoring their performance and impact before wider adoption.
• Rollback Procedures: Develop clear rollback plans to quickly revert changes if issues are detected during deployment.

3. Monitoring: Measure and Optimize Agent Performance

Comprehensive monitoring is critical to maintaining and improving Agentforce 2.0 performance:

• Agent Performance Metrics: Track reasoning accuracy, response times, and user engagement to identify areas for improvement.
• Reasoning Accuracy Tracking: Measure the success rate of System 1 (fast) and System 2 (deep) reasoning to optimize agent workflows.
• API Utilization Monitoring: Monitor API call frequency, error rates, and quota usage to ensure system health and avoid bottlenecks.
• Security Audit Logging: Maintain detailed logs of agent activities and API calls for compliance and security audits.

4. Performance Optimization: Maximize Efficiency

Agentforce 2.0 introduces advanced reasoning and orchestration capabilities that require careful resource management:

• Response Time Management: Balance System 1 and System 2 reasoning for fast and accurate responses, leveraging caching and query optimization techniques.
• Async Processing Patterns: Use asynchronous processing for long-running workflows to prevent system delays.
• Caching Strategies: Implement caching mechanisms for frequently accessed data to reduce response times and API calls.
• Resource Allocation: Ensure adequate compute, memory, and storage resources are available to support high-demand agent activities.

5. Scalability Considerations: Prepare for Growth

Agentforce 2.0’s capabilities are designed to scale with enterprise needs, but proactive planning is essential:

• Multi-Region Deployment: Deploy agents across multiple regions to ensure low latency and high availability for global users.
• Load Balancing: Distribute workloads evenly across resources to prevent bottlenecks and downtime.
• Rate Limiting: Implement rate-limiting strategies to avoid overloading APIs and other system components.
• Failover Strategies: Establish failover protocols to maintain service continuity during outages or unexpected surges.

6. Security and Compliance: Protect Data and Systems

The integration of intelligent agents with enterprise systems demands a heightened focus on security:

• Attribute-Based Access Control: Implement granular access controls to ensure agents and users only access authorized data.
• Data Residency Management: Comply with regional data residency requirements by deploying agents and data services in appropriate locations.
• Encryption Key Management: Regularly rotate encryption keys to safeguard sensitive data.
• Audit Trail Generation: Maintain comprehensive audit trails for all agent activities to support compliance and troubleshooting efforts.

7. Collaborative Workflow Development: Bridge Gaps Between Teams

The success of Agentforce 2.0 deployments relies on cross-functional collaboration:

• Unified Development Practices: Align DevOps, AI development, and business teams to ensure agent capabilities meet organizational goals.
• Iterative Testing: Adopt an agile approach to testing agent configurations and workflows, incorporating feedback from users and stakeholders.
• Knowledge Sharing: Promote knowledge-sharing sessions to keep all teams informed about Agentforce updates and best practices.

Conclusion

The transformative potential of Salesforce Agentforce 2.0 comes with new operational challenges and opportunities. By following these best practices, DevOps teams can ensure a smooth implementation process, unlock the platform’s full capabilities, and deliver unparalleled AI-powered solutions to their organizations. Careful planning, robust monitoring, and a commitment to continuous improvement will be key to success.

Roeslein & Associates, a global leader in construction and engineering, had complex business processes that could not scale to meet its needs. It wanted to set standard manufacturing processes to fulfill highly customized demand originating from its customers.

Roeslein chose Oracle Fusion Cloud SCM, which included Project-Driven Supply Chain for Inventory, Manufacturing, Order Management, Procurement, and Cost Management, and partnered with Perficient to deliver the implementation.

Join us as project manager, Ben Mitchler, discusses the migration to Oracle Cloud. Jeff Davis, Director, Oracle ERP at Perficient will be joining Ben to share this great PDSC story.

Discussion will include:

• Challenges with the legacy environment
• On-premises to cloud migration approach
• Benefits realized with the global SCM implementation

Save the date for this insightful webinar taking place January 22, 2025! Register now!

An Oracle Partner with 20+ years of experience, we are committed to partnering with our clients to tackle complex business challenges and accelerate transformative growth. We help the world’s largest enterprises and biggest brands succeed. Connect with us at the show to learn more about how we partner with our customers to forge the future.

Three years ago, I started my journey with Adobe Experience Manager (AEM) and I still remember how overwhelmed I was when I started using it. As a front-end developer, my first task in AEM – implementing responsive design – was no cakewalk and required extensive problem solving. 

In this blog, I share the 10 tips and tricks I’ve learned to help solve problems faced by front-end developers. Whether you’re exploring AEM for the first time or seeking to enhance your skills, these tips will empower you to excel in your role as a front-end developer in the AEM ecosystem. 

1. Get Familiar With AEM Architecture

My first tip is to understand AEM’s architecture early on.   

• Learn Core Concepts – Before diving into code, familiarize yourself with AEM’s components, templates, client libraries, and the content repository. Learn how each of the components interact and fit in your application. 

• Sling and JCR (Java Content Repository) – Gain a basic understanding of Apache Sling (the web framework AEM is built on) and how JCR stores content. This foundational knowledge will help you understand how AEM handles requests and manages content. 

• Get Familiar with CRXDE Lite – CRXDE Lite is a lightweight browser-based development tool that comes out of the box with Adobe Experience Manager.   Using CRXDE Lite developers can access and modify the repository in your local development environments within the browser. You can edit files, folders, nodes, and properties. The entire repository is accessible to you in this easy-to-use interface. Keep in mind that CRXDE offers you the possibility to make instant changes to the website. You can even synchronize these changes with your code base using plugins for the most used most used code editors like Visual Studio Code, Brackets, and Eclipse. 

• Content Package – An AEM front-end developer needs to work on web pages, but we don’t have to create them from the beginning.  We can use the CRXDE Lite build and download content to share with other developers or bring content from production to local development environments.  

The above points are the basic building blocks that FE developers should be aware of to start with. For more detail read check out the AEM architecture intro on Adobe Experience League.

2. Focus on HTML Template Language (HTL)

AEM uses HTL, which is simpler and more secure than JSP. Start by learning how HTL works, as it’s the main way you’ll handle markup in AEM. It’s similar to other templating languages, so you’ll likely find it easy to grasp.

3. Master Client Libraries (Clientlibs)

Efficient Management of CSS/JS  

AEM uses client libraries (in short clientlibs) to manage and optimize CSS and JavaScript files. So, it’s important to learn how to organize CSS/JS files efficiently as categories and dependencies. This helps load only the required CSS/JS for a webpage to help with page performance.   

Minimize and Bundle

Use Out of the Box Adobe Granite HTML Library Manager (com.adobe.granite.ui.clientlibs.impl.HtmlLibraryManagerImpl) OSGI configuration to minify the CSS/JS that will build small file size for CSS/JS and boost in page load time.  

For more information check out Adobe Experience League.  

4. Leverage AEM’s Component-Based Architecture

Build components with reusability in mind. AEM is heavily component-driven, and your components will be used across different pages. Keeping them modular will allow authors to mix and match them to create new pages. 

5. Use AEM’s Editable Templates

Editable templates are better than static. AEM’s editable templates give content authors control over layout without developer intervention. As a front-end developer, CSS/JS that we build must be independent of templates.  Clientlib related to a UI component should work without any issues on any template-based pages. 

6. Get Familiar with AEM Development Tools

There are multiple development tools that you can find within the most used text editors like Brackets, Visual Studio Code and Eclipse. You should use these extensions to speed up your development process. These tools help you synchronize your local environment with AEM, making it easier to test changes quickly.   

Check out Experience League for more information.  

7. Start With Core Components

AEM comes with a set of core components that cover many basic functionalities such as text, image, carousel. Using the core components as building blocks (extending) to build custom components, saves development time and follows best practices.  For more details check out the following links:  

• https://experienceleague.adobe.com/en/docs/experience-manager-core-components/using/introduction 

• https://www.aemcomponents.dev

8. Understand the AEM Content Authoring Experience

Work With Content Authors  

As a front-end developer, it’s important to collaborate closely with content authors. Build components and templates that are intuitive to use and provide helpful options for authors. By doing this, you will gain understanding about how authors use your components and will help you make them more “user friendly” each time. 

Test Authoring

Test the authoring experience frequently to ensure that non-technical users can easily create content. The easier you make the interface the less manual intervention will be required later. 

9. Keep Accessibility in Mind

Accessibility First  

Make sure your components are accessible. AEM is often used by large organizations, where accessibility is key. Implement best practices like proper ARIA roles, semantic HTML, and keyboard navigation support. I have spent some time on different projects enhancing accessibility attributes. So, keep it in mind. 

AEM Accessibility Features  

Leverage AEM’s built-in tools for accessibility testing and ensure all your components meet the required standards (e.g., WCAG 2.1). For more information, you can read the Experience League article on accessibility.  

10. Leverage AEM’s Headless Capabilities

Headless CMS With AEM

Explore how to use AEM as a headless CMS and integrate it with your front end using APIs. This approach is particularly useful if you’re working with modern front-end frameworks like React, Angular, or Vue.js. 

GraphQL in AEM

AEM offers GraphQL support, allowing you to fetch only the data your front end needs. Start experimenting with AEM’s headless features to build SPAs or integrate with other systems. 

SPA Editor

The AEM SPA Editor is a specialized tool in Adobe Experience Manager designed to integrate Single Page Applications (SPAs) into the AEM authoring environment. It enables developers to create SPAs using modern frameworks like React and Angular out of the box while allowing content authors to edit and manage content within AEM, just as they would with traditional templates. Do you remember when I mentioned the developer tools for IDEs? Well, there is one to map your spa application to work with AEM ecosystem.   

More Insights for AEM Front-End Developers

In this blog, we’ve discussed AEM architecture, HTL, Clientlibs, templates, tools, components, authoring, accessibility, and headless CMS as focus areas to help you grow and excel as an AEM developer.  

If you have questions, feel free to drop the comments below. And if you have any tips not mentioned in this blog, feel free to share those as well!  

And make sure to follow our Adobe blog for more Adobe platform insights! 

Managing configurations in Adobe Experience Manager (AEM) can be challenging, especially when sharing configs across different websites, regions, or components.  The Context-Aware Configuration (CAC) framework in AEM simplifies configuration management by allowing developers to define and resolve configurations based on the context, such as the content hierarchy. However, as projects scale, configuration needs can become more intricate, involving nested configurations and varying scenarios. 

In this blog, we will explore Nested Context-Aware Configurations and how they provide a scalable solution to handle multi-layered and complex configurations in AEM. We’ll cover use cases, the technical implementation, and best practices for making the most of CAC. 

Understanding Nested Context-Aware Configuration

AEM’s Context-Aware Configuration allows you to create and resolve configurations dynamically, based on the content structure, so that the same configuration can apply differently depending on where in the content tree it is resolved. However, some projects require deeper levels of configurations — not just based on content structure but also different categories within a configuration itself. This is where nested configurations come into play. 

Nested Context-Aware Configuration involves having one or more configurations embedded within another configuration. This setup is especially useful when dealing with hierarchical or multi-dimensional configurations, such as settings that depend on both global and local contexts or component-specific configurations within a broader page configuration. 

You can learn more about basic configuration concepts on Adobe Experience League.

Categorizing Configurations with Nested Contexts

Nested configurations are particularly useful for categorizing configurations based on broad categories like branding, analytics, or permissions, and then nesting more specific configurations within those categories. 

For instance, at the parent level, you could define global categories for analytics tracking, branding, or user permissions. Under each category, you can then have nested configurations for region-specific overrides, such as: 

• Global Analytics Config: Shared tracking ID for the entire site. 
• Regional Analytics Config: Override global analytics tracking for specific regions. 
• Component Analytics Config: Different tracking configurations for components that report analytics separately. 

This structure: 

• Simplifies management: Reduces redundancy by categorizing configurations and using fallback mechanisms. 
• Improves organization: Each configuration is neatly categorized and can be inherited from parent configurations when needed. 
• Enhances scalability: Allows for easy extension and addition of new nested configurations without affecting the entire configuration structure. 

Benefits of Nested Context-Aware Configuration

1. Scalability: Nested configurations allow you to scale your configuration structure as your project grows, without creating redundant or overlapping settings. 
2. Granularity: Provides fine-grained control over configurations, enabling you to apply specific settings at various levels (global, regional, component). 
3. Fallback Mechanism: If a configuration isn’t found at a specific level, AEM automatically falls back to a parent configuration, ensuring that the system has a reliable set of defaults to work with. 
4. Maintainability: By organizing configurations hierarchically, you simplify maintenance. Changes at the global level automatically apply to lower levels unless explicitly overridden.

Advanced Use Cases

1. Feature Flag Management: Nested CAC allows you to manage feature flags across different contexts. For example, global feature flags can be overridden by region or component-specific feature flags. 
2. Personalization: Use nested configurations to manage personalized experiences based on user segments, with global rules falling back to more specific personalization at the regional or page level. 
3. Localization: Nested CAC can handle localization configurations, enabling you to define language-specific content settings under broader regional or global configurations. 

Implementation

To implement the nested configurations, we need to define configurations for individual modules first. In the example below, we are going to create SiteConfig which will have some configs along with two Nested configs and then Nested config will have its own attributes. 

Let’s define Individual config first. Th they will Look like this: 

@Configuration(label = "Global Site Config", description = "Global Site Context Config.") 
public @interface SiteConfigurations { 
 
    @Property(label = "Parent Config - Property 1", 
            description = "Description for Parent Config Property 1", order = 1) 
    String parentConfigOne(); 
 
    @Property(label = "Parent Config - Property 2", 
            description = "Description for Parent Config Property 2", order = 2) 
    String parentConfigTwo(); 
 
    @Property(label = "Nested Config - One", 
            description = "Description for Nested Config", order = 3) 
    NestedConfigOne NestedConfigOne(); 
 
    @Property(label = "Nested Config - Two", 
            description = "Description for Nested Config", order = 4) 
    NestedConfigTwo[] NestedConfigTwo(); 
 
}

Following with this Nested ConfigOne and NestedConfigTwo will look like this: 

public @interface NestedConfigOne { 
 
    @Property(label = "Nested Config - Property 1", 
            description = "Description for Nested Config Property 1", order = 1) 
    String nestedConfigOne(); 
 
 
    @Property(label = "Nested Config - Property 2", 
            description = "Description for Nested Config Property 2", order = 2) 
    String nestedConfigTwo(); 
 
 
}

And…

public @interface NestedConfigTwo { 
 
    @Property(label = "Nested Config - Boolean Property 1", 
            description = "Description for Nested Config Boolean Property 1", order = 1) 
    String nestedBooleanProperty(); 
 
    @Property(label = "Nested Config - Multi Property 1", 
            description = "Description for Nested Config Multi Property 1", order = 1) 
    String[] nestedMultiProperty(); 
 
}

Note that we didn’t annotate nested configs with Property as this is not the main config.  

Let’s create service to read this and it will look like this:

public interface NestedConfigService { 
    SiteConfigurationModel getAutoRentalConfig(Resource resource); 
}

Implementation of service will be like this: 

@Component(service = NestedConfigService.class, 
        immediate = true) 
@ServiceDescription("Implementation For NestedConfigService") 
public class NestedConfigServiceImpl implements NestedConfigService { 
 
    @Override 
    public SiteConfigurationModel getAutoRentalConfig(Resource resource) { 
        final SiteConfigurations configs = getConfigs(resource); 
        return new SiteConfigurationModel(configs); 
    } 
 
    private SiteConfigurations getConfigs(Resource resource) { 
        return resource.adaptTo(ConfigurationBuilder.class) 
                .name(SiteConfigurations.class.getName()) 
                .as(SiteConfigurations.class); 
    } 
 
}

SiteConfigurationModel will hold the final config including all the configs. We can modify getters based on need. So currently, I am just adding its dummy implementation. 

public class SiteConfigurationModel { 
    public SiteConfigurationModel(SiteConfigurations configs) { 
 
        String parentConfigOne = configs.parentConfigOne(); 
        NestedConfigOne nestedConfigOne = configs.NestedConfigOne(); 
        NestedConfigTwo[] nestedConfigTwos = configs.NestedConfigTwo(); 
        //Construct SiteConfigurationModel As per Need 
 
    } 
}

Once you deploy the code On site config menu in context editor, it should look like :  

We can see it has given us the ability to configure property 1 and property 2 directly but for Nested one it gave an additional Edit button which will take us to configure the Nested Configs and it will look like this : 

Since Nested config two is multifield it gives the ability to add an additional entry. 

A Powerful Solution to Simplify and Streamline

Nested Context-Aware Configuration in AEM offers a powerful solution for managing complex configurations across global, regional, and component levels. By leveraging nested contexts, you can easily categorize configurations, enforce fallback mechanisms, and scale your configuration management as your project evolves. 

Whether working on a multi-region site, handling diverse user segments, or managing complex components, nested configurations can help you simplify and streamline your configuration structure while maintaining flexibility and scalability. 

Learn More

Make sure to follow our Adobe blog for more Adobe platform insights! 

Hello Trailblazers!

Salesforce Schema Builder is a robust tool that provides a visual representation of your data model. It allows administrators and developers to view, design, and modify objects, fields, and relationships in Salesforce effortlessly. Whether you’re a seasoned Salesforce expert or a beginner, Schema Builder can simplify your work and enhance your understanding of the Salesforce data architecture.

What is Schema Builder?

Schema Builder is a dynamic tool within Salesforce that visually represents objects, fields, and their relationships. Unlike the traditional method of navigating through object manager tabs, Schema Builder provides a drag-and-drop interface for creating and editing objects and fields directly.

Key Features of Schema Builder

1. Interactive Visualization: View all standard and custom objects along with their relationships in a single diagram.
2. Drag-and-Drop Interface: Create new objects, fields, and relationships without writing any code.
3. Field Details: Easily access field-level information such as data type and API name.
4. Real-Time Updates: The changes made in Schema Builders are reflected immediately in the Salesforce org.
5. Customizable View: Filter objects and relationships to focus on specific areas of your schema.

Benefits of Using Schema Builder

1. Time-Saving: Simplifies the process of designing and modifying your data model.
2. Improved Collaboration: Provides a clear visual representation that can be shared with stakeholders.
3. Reduced Errors: Ensures accuracy in creating fields and relationships by providing instant feedback.
4. Enhanced Understanding: Helps new team members quickly understand the data model.

How to Access Schema Builder

Follow these steps to access Schema_Builder in Salesforce:

1. Log in to your Salesforce org.
2. To access Setup, click the gear symbol in the top-right corner.
3. In the Quick Find box, type Schema Builder.
4. Click on Schema Builder under Objects and Fields as shown in the figure below.

Once the Schema Builders interface opens, you can view and interact with your data model.

Start Using Schema Builder:

1. In the left panel, click Clear All to remove any existing selections.
2. Select the Account, Contact, and Opportunity
3. Click on Auto-Layout to automatically arrange the components.

Once done, the layout will look similar to this:

Note: You can easily drag these objects around the canvas in Schema_Builder. While this doesn’t alter the objects or their relationships, it allows you to better visualize your data model in an organized and meaningful way.

Schema Builder is a powerful tool for showcasing your Salesforce customizations to colleagues or visualizing the seamless flow of data across your system, making it easier to understand and explain your data model.

Using Schema Builder to Create Objects, Fields, and Relationships

Step 1: Create a Custom Object

1. Open Schema Builder.
2. Click on Elements in the top-left corner.
3. Drag the Object icon onto the canvas.
4. Fill in the required details like Object Label, Record Name, Data type, etc.
5. Save the object as shown below.

The object we created, will look like this.

And now you can start adding or creating the fields into the object.

Step 2: Add Fields to an Object

1. Drag the Field icon onto an existing object in the canvas from the Elements.
2. Choose the field type (e.g., Text, Number, Date).
3. Specify field details like Field Label and Field Name.
4. Save the field.

Step 3: Create Relationships Between Objects

1. Drag the Lookup Relationship or Master-Detail Relationship icon onto an object.
2. Specify the related object.
3. Define the relationship settings, such as field names and sharing rules.
4. Save the relationship.

So, the object will look like this after adding the fields.

So, in this way, you can create objects from Schema_Builder itself without going to Object Manager.

Best Practices for Using Schema Builder

1. Plan Your Data Model: Outline your objects, fields, and relationships before starting.
2. Use Filters: Focus on specific objects or relationships to reduce clutter.
3. Collaborate with Teams: Share the Schema Builders view with your team to ensure alignment.
4. Test Before Deployment: Validate the changes in a sandbox environment before applying them in production.

Limitations of Schema Builder

1. Performance Issues: For orgs with large numbers of objects and fields, Schema_Builder can become slow.
2. Limited Functionality: Advanced customizations, like triggers and validation rules, cannot be managed through Schema Builder.
3. No Version Control: Changes made in Schema Builders are not version-controlled, so careful tracking is necessary.

Note: To dive deeper into the considerations for using Schema Builders, feel free to explore further by following this link.

Conclusion

Schema Builder in Salesforce is an invaluable tool for visualizing and managing your data model. By providing a user-friendly interface and real-time updates, it simplifies complex data architecture tasks and improves collaboration across teams.

Happy Reading!

 “Continuous learning is the bridge between where you are and where you aspire to be. Every step forward, no matter how small, brings growth and opens doors to new possibilities.”

Related Posts:

1. Work with Schema_Builder
2. Design your own Data Model with Schema_Builder

You Can Also Read:

1. Introduction to the Salesforce Queues – Part 1
2. Mastering Salesforce Queues: A Step-by-Step Guide – Part 2
3. How to Assign Records to Salesforce Queue: A Complete Guide
4. An Introduction to Salesforce CPQ
5. Revolutionizing Customer Engagement: The Salesforce Einstein Chatbot

Developer tools and practices have evolved significantly over the last decade. Earlier developer ecosystems were IDE e.g. Eclipse, Visual Studio, technical self-help books, stack overflow, and Google. Artificial intelligence terms were first time used in 1956. AI tools have become so popular because of increasing data volumes, advanced algorithms, and computing power and storage improvements. With the evolving times, we have varied options to get assistance for developers, testers, and business analysts.

Before AI Tools Launch

• Earlier developers may spend a lot of time finding issues with a minor syntax error in the string formation.
• Earlier developers had to look and browse various links on Google to search for a solution and read multiple suggestions.

What is GitHub Copilot?

GitHub Copilot is an AI coding assistant that helps you write code faster and with less effort, allowing us to focus more energy on problem-solving, collaboration, and domain. GitHub Copilot has been proven to increase developer productivity and accelerate the pace of software development.

Why use GitHub Copilot: Copilot is a powerful tool in the right hand.

• It generates code snippets for the developer.
• It suggests new code syntax the framework launches
• Design pattern suggestion and explanation
• Get code performance suggestions
• Developers can even master new coding language
• Developers need not leave their development environment to get the solutions. They can just type keywords in their environment and get solutions.

How GitHub Copilot Works

Open AI Codex, a machine learning model that translates natural language into code, powers GitHub Copilot to draw context from comments and code to suggest individual lines and whole functions as you type. Codex is a version of GPT-3 (Generative Pre-trained Transformer 3) fine-tuned for programming tasks.

Features of GitHub Copilot

• Suggests code as we type in IDE
• Chat: We can prompt and get suggestions
• Command line tool: Get code suggestions in the Command line
• Copilot Enterprise only: Get a description of the changes for pull requests
• Autocomplete repetitive sections of code for the method and functions
• Policy management for administrators
• Conversion of code comments to runnable code
• Access management for enterprise owners and organization owners

Real-time Usage of GitHub Copilot

1. Generate class file for JSON structure for API.
2. Write test case for the Method or function
3. Generate string for JSON output for post request in API
4. IntelliSense suggesting code like assistant and developer can accept the code

Different types of subscription for Copilot:

• CoPilot Individual: For individual developers, freelancers, students, and educators.
• CoPilot Business: For organizations ready to improve engineering velocity, code quality, and developer experience.
• CoPilot Enterprise: For companies looking for the most customization based on their organization’s knowledge and codebase.

For more information on the cost, we can get it from the below URL. We can use free trial or buy any of the above plan from this URL and there are contact sales: GitHub Copilot · Your AI pair programmer · GitHub. Even for free trial we need to provide credit card information.

Advantages of using GitHub copilot

• Git hub copilot is auto enabled in the IDE (Visual Studio, VSCode, Eclipse) it keeps suggesting us auto complete code.
• Suggests code for object initialization for a class, Writes test cases. To achieve code coverage of 85% or above developer needs to complete it in few hours hence it improves developer productivity
• Provides suggestions for a new framework and developers can type their question in chat and get appropriate responses. 

Realtime use cases for GitHub Copilot.

1. Code Snippet for Class Person in C# which has nested class and generating JSON for this Sample response from GitHub Copilot when we want to test Web API POST request with sample data

Class Person
{
   public Name PersonName { get; set; }
   public Address PersonAddress { get; set; }
   public int Height { get; set; }
   public string EyeColor { get; set; }
}

Public Class PersonName
{
   public string FirstName { get; set; }
   public string LastName { get; set; }
}

Public class Address
{
    public string AddressLine1 { get; set; }
    public string AddressLine2 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string State { get; set; }
    public string ZipCode { get; set; }
}

2.  Prompt to GitHub is convert to string datatype.

"{\n" +
            "  \"PersonName\": {\n" +
            "    \"FirstName\": \"John\",\n" +
            "    \"LastName\": \"Doe\"\n" +
            "  },\n" +
            "  \"PersonAddress\": {\n" +
            "    \"AddressLine1\": \"123 Main St\",\n" +
            "    \"AddressLine2\": \"Apt 4B\",\n" +
            "    \"City\": \"Anytown\",\n" +
            "    \"State\": \"CA\",\n" +
            "    \"ZipCode\": \"12345\"\n" +
            "  },\n" +
            "  \"Height\": 180,\n" +
            "  \"EyeColor\": \"Brown\"\n"

3. Explain repository pattern: Below response from Github Copilot

Key Concepts:

• Repository: A class that acts as an intermediary between the business logic layer and the data layer (database). It hides the details of data access and allows the business logic to work with an abstracted interface.
• Interface: The repository often exposes an interface, allowing for flexibility in how data is retrieved and stored (e.g., from a database, in-memory, or an external service).
• Abstraction: The repository provides an abstraction of the underlying data source, allowing the rest of the application to work with simple method calls without knowing the details of how data is stored or fetched.

Benefits of the Repository Pattern:

• Separation of concerns: Keeps the data access logic isolated from the business logic.
• Testability: Allows for easier unit testing by mocking the repository in tests.

Maintainability: Easier to manage changes to data access logic without impacting the rest of the application.

4. Writing Test cases. Prompt to Github Copilot is write test case for split a string using MOQ

Sure! Here's an example of how you can write a test case using Moq for a string with the value "one, two, three, four, five":

```csharp
using Moq;
using Xunit;

public class StringServiceTests
{
    [Fact]
    public void TestStringService()
    {
        // Arrange
        var mockStringService = new Mock();
        string testString = "one, two, three, four, five";
        mockStringService.Setup(service => service.GetString()).Returns(testString);

        // Act
        var result = mockStringService.Object.GetString();

        // Assert
        Assert.Equal(testString, result);
    }
}

public interface IStringService
{
    string GetString();
}
```

In this example:
- We create a mock of the `IStringService` interface.
- We set up the mock to return the string "one, two, three, four, five" when the `GetString` method is called.
- We then call the `GetString` method on the mock object and assert that the returned value is equal to the expected string.

Feel free to ask if you need further assistance or have any questions!

GitHub is available for following IDE

Visual Studio, Visual Studio Code, JetBrains

GitHub Supports Following programming languages: Python, JavaScript, TypeScript, Go, and Ruby 

Downside of using GitHub Copilot:

• GitHub copilot keeps on suggesting code which a developer may not intend to write is kind of annoying.
• It may generate code based on the prompt we provide which may have some error and developer must rework accordingly
• Once Copilot is integrated into the developer environment it will prompt to press tab to accept the code which may be incorrect, developer completely needs to always use their discretion.
• Hence it is a powerful tool in the right hand.

Quotes from one of the news about AI tools

I would like to reference a statement by “Nvidia CEO Jensen Huang at the recent World Government Summit in Dubai said youngsters should stop focusing on how to code, at this early stage of AI revolution programming is no longer a vital skill. Coding can be taken care of by AI, humans can take care of more important expertise like domain, biology, education, farming etc.”.

Conclusion:

This tool can be very well utilized by the adept developers and also by new developers for their focused learning and work towards organization productivity.

It is the time to evolve our beliefs and work alongside AI powered tools enhance our knowledge and learn to use these tools so that we could get along with changing times.

Developers can focus on enriching user experience with their product and bring in more innovation.

Building GitLab CI/CD Pipelines with AWS Integration

GitLab CI/CD (Continuous Integration/Continuous Deployment) is a powerful, integrated toolset within GitLab that automates the software development lifecycle (SDLC). It simplifies the process of building, testing, and deploying code, enabling teams to deliver high-quality software faster and more efficiently.

Understanding GitLab CI/CD

Getting started with GitLab CI/CD is simple. Start by creating a GitLab account and setting up a project for your application if you don’t have then install and configure a GitLab Runner, a tool responsible for executing the tasks defined in your .gitlab-ci.yml file. The runner handles building, testing, and deploying your code, ensuring the pipeline works as intended. This setup streamlines your development process and helps automate workflows efficiently.

What is a GitLab Pipeline?

A pipeline automates the process of building, testing, and deploying applications. CI (Continuous Integration) means regularly merging code changes into a shared repository. CD (Continuous Deployment/Delivery) automates releasing the application to its target environment.

Related CODE: In this step, you push your local code changes to the remote repository and commit any updates or modifications.

CI Pipeline: Once your code changes are committed and merged, you can run the build and test jobs defined in your pipeline. After completing these jobs, the code is ready to be deployed to staging and production environments.

Important Terms in GitLab CI/CD

1. .gitlab-ci.yaml file

A .gitlab-ci.yml file in a GitLab repository is used to define the Continuous Integration/Continuous Deployment (CI/CD) pipeline configuration. This file contains instructions on building, testing, and deploying your project.

2. Gitlab-Runner

In GitLab CI/CD, a “runner” refers to the agent that executes the jobs defined in the .gitlab-ci.yml pipeline configuration. Runners can be either shared or specific to the project.

Here’s how runners work:

1. Shared Runners: GitLab provides shared runners available to all projects within a GitLab instance. These runners are managed by GitLab administrators and can be used by any project. Shared runners are convenient if we don’t want to set up and manage our own runners.
2. Specific Runners: We can also set up our own runners that are dedicated to our project. These runners can be deployed on our infrastructure (e.g., on-premises servers, cloud instances) or using a variety of methods like Docker, Kubernetes, shell, or Docker Machine. Specific runners offer more control over the execution environment and can be customized to meet the specific needs of our project.

3. Pipeline:

Pipelines are made up of jobs and stages:

• Jobs define what you want to do. For example, test code changes, or deploy to a dev environment.
• Jobs are grouped into stages. Each stage contains at least one job. Common stages include build, test, and deploy.
• You can run the pipeline either manually or from the pipeline schedule Job.

First is manually means directly commit, when you merged or commit any changes into code pipeline directly trigger.

And second is by using rules for that, you need to create a scheduled job.

 4. Schedule Job:

We use scheduled jobs to automate pipeline execution. To create a scheduled job, follow these steps:

1. Navigate to Schedule Settings: Go to Build, select Pipeline Schedules, and click Create New Schedule.
2. Configure Schedule Details:
   1. Description: Enter a name for the scheduled job.
   2. Cron Timezone: Set the timezone according to your requirements.
   3. Interval Pattern: Define the cron schedule to determine when the pipeline should run. If you   prefer to run it manually by clicking the play button when needed, uncheck the Activate button at the end.
   4. Target Branch: Specify the branch where the cron job will run.
3. Add Variables: Include any variables mentioned in the rules section of your .gitlab-ci.yml file to ensure the pipeline runs correctly.
   1. Input variable key = SCHEDULE_TASK_NAME
   2. Input variable value = prft-deployment

Demo

Prerequisites for GitLab CI/CD 

• GitLab Account and Project: You need an active GitLab account and a project repository to store your source code and set up CI/CD workflows.
• Server Environment: You should have access to a server environment, like a AWS Cloud, where your install gitlab-runner.
• Version Control: Using a version control system like Git is essential for managing your source code effectively. With Git and a GitLab repository, you can easily track changes, collaborate with your team, and revert to previous versions whenever necessary.

Configure Gitlab-Runner

• Launch an AWS EC2 instance with any operating system of your choice. Here, I used Ubuntu. Configure the instance with basic settings according to your requirements.
• SSH into the EC2 instance and follow the steps below to install GitLab Runner on Ubuntu.

1. sudo apt install -y curl
2. curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash
3. sudo apt install gitlab-runner

After installing GitLab Runner, proceed to register it. Navigate to GitLab, go to Settings, then CI/CD, and under Runners, click on the three dots to access the registration options.

And copy-paste the below cmd:

Run the following command on your EC2 instance and provide the necessary details for configuring the runner based on your requirements:

1. URL: Press enter to keep it as the default.
2. Token: Use the default token and press enter.
3. Description: Add a brief description for the runner.
4. Tags: This is critical; the tag names define your GitLab Runner and are referenced in your .gitlab-ci.yml file.
5. Notes: Add any additional notes if required.
6. Executor: Choose shell as the executor.

Check GitLab-runner status and active status using the below cmd:

• gitlab-runner verify
• gitlab-runner list

Check gitlab-runner is active in gitlab also:

Navigate to GitLab, then go to Settings and select GitLab Runners.

 Configure gitlab-ci.yaml file

• Stages: Stages that define the sequence in which jobs are executed.
  • build
  • deploy
• Build-job: This job is executed in the build stage, the first run stage.
  • Stage: build
  • Script:
    • Echo “Compiling the code…”
    • Echo “Compile complete.”‘
  • Rules:
    • if: ‘$CI_PIPELINE_SOURCE == “schedule” && $SCHEDULE_TASK_NAME == “prft-deployment”‘
  • Tags:
    • prft-test-runner
• Deploy-job: This job is executed in the deploy stage.
  • Stage: deploy   #It will only execute when both jobs in the build job & test job (if added) have been successfully completed.
  • script:
    • Echo “Deploying application…”
    • Echo “Application successfully deployed.”
  • Rules:
    • if: ‘$CI_PIPELINE_SOURCE == “schedule” && $SCHEDULE_TASK_NAME == “prft-deployment”‘
  • Tags:
    • prft-test-runner

Note: If needed, you can add a test job similar to the BUILD and DEPLOY jobs.

Run Pipeline

Since the Cron job is already configured in the schedule, simply click the Play button to automatically trigger your pipeline.

To check pipeline status, go to Build and then Pipeline. Once the Build Job is successfully completed, the Test Job will start, and once the Test Job is completed, the deploy job will start.

Output

We successfully completed BUILD & DEPLOY Jobs.

Build Job

Deploy Job

Conclusion

As we can see, the BUILD & DEPLOY jobs pipeline has successfully passed.

We’ve provided a brief overview of GitLab CI/CD pipelines and a practical demonstration of how its components work together. Hopefully, everything is running smoothly on your end!

In the world of modern web development, enhancing user experience is a top priority. One of the most popular features for improving searchability is the “Typeahead” functionality, which provides dynamic suggestions as users type. This feature can significantly speed up data entry, reduce errors, and make your application feel more responsive.

In this blog, we’ll walk you through how to implement a Typeahead in a Salesforce Lightning Web Component (LWC). Whether you’re building a search box for records or a dynamic filtering system, this guide will give you the tools and understanding to implement this feature seamlessly in your Salesforce environment.

What is a Typeahead?

A Typeahead (also known as autocomplete) is a UI feature that automatically suggests possible matches based on the characters typed by the user. It helps users quickly find data by filtering through large datasets without having to type the full query. The suggestions are generally retrieved in real time based on the user’s input.

For example, as the user starts typing the name of a contact, the typeahead feature would suggest matching names from the Salesforce database.

Salesforce LWC Typeahead: Key Considerations

1. Data Source: The data for typeahead suggestions typically comes from Salesforce records or external APIs. It’s important to efficiently fetch the right data.
2. Search Threshold: Rather than fetching all records at once, limiting the number of results based on the search term is better to reduce load and enhance performance.
3. User Experience (UX): Ensure that the suggestions appear as the user types and can be easily selected from the list.

Step 1: Setup the Lightning Web Component (LWC)

To begin, let’s create the basic structure of the Lightning Web Component. We’ll need an HTML file, a JavaScript file, and a CSS file.

1.1 Create the HTML File

<template>
    <lightning-input label="Search Contacts" 
                     value={searchTerm} 
                     onchange={handleSearchChange} 
                     placeholder="Search for a contact..." 
                     aria-live="assertive" 
                     class="search-box">
    </lightning-input>

    <template if:true={suggestions.length}>
        <ul class="sugg-list">
            <template for:each={suggestions} for:item="suggestion">
                <li key={suggestion.Id} class="sugg-item" onclick={handleSuggestionSelect}>
                    {suggestion.Name}
                </li>
            </template>
        </ul>
    </template>
</template>

Explanation

• <lightning-input>: This is the input box where users will type their query. We bind it to a property searchTerm and set up an event listener handleSearchChange.
• Suggestions: If there are matching results, a list (<ul>) is displayed, showing the names of the suggested contacts.

1.2 Create the JavaScript File

     public void buildPathMap() {
        for (AssetNode node : refObj.values()) {
            if (!pathMap.containsKey(node.id)) {
                String path = getPath(node);
                pathMap.put(node.id, path);
            }
        }
    }

    // Recursive method to get the full path of a node
    private String getPath(AssetNode node) {
        if (String.isBlank(node.parentId)) {
            return node.name; // Base case: root node
        }
        AssetNode parentNode = refObj.get(node.parentId);
        if (parentNode != null) {
            String parentPath = getPath(parentNode);
            return parentPath + ' > ' + node.name;
        }
        return node.name; // In case parent doesn't exist
    }

    // Getter for the path map
    public Map<String, String> getPathMap() {
        return pathMap;
    }import { LightningElement, track } from 'lwc';
import searchContacts from '@salesforce/apex/ContactController.searchContacts';

export default class TypeaheadSearch extends LightningElement {
    @track searchTerm = '';
    @track suggestions = [];

    // Handle input changes
    handleSearchChange(event) {
        this.searchTerm = event.target.value;
        if (this.searchTerm.length > 2) {
            this.fetchSuggestions();
        } else {
            this.suggestions = [];
        }
    }

    // Fetch contact suggestions
    fetchSuggestions() {
        searchContacts({ searchTerm: this.searchTerm })
            .then((result) => {
                this.suggestions = result;
            })
            .catch((error) => {
                console.error("Error fetching suggestions", error);
                this.suggestions = [];
            });
    }

    // Handle suggestion click
    handleSuggestionSelect(event) {
        this.searchTerm = event.target.innerText;
        this.suggestions = [];
    }
}

Explanation

• handleSearchChange(): This method is triggered whenever the user types in the input box. If the user types more than 2 characters, it calls fetchSuggestions() to retrieve the matching results.
• fetchSuggestions(): This calls an Apex method (searchContacts) that queries the Salesforce records and returns matching contacts based on the searchTerm.
• handleSuggestionSelect(): When a user clicks on a suggestion, the search term is updated with the selected suggestion, and the list of suggestions is cleared.

1.3 Create the Apex Controller

Now, let’s create the Apex class that fetches the suggestions. This Apex class will use a SOQL query to find contacts based on the search term.

public class ContactController {
    @AuraEnabled(cacheable=true)
    public static List<Contact> searchContacts(String searchTerm) {
        String searchQuery = '%' + searchTerm + '%';
        return [SELECT Id, Name FROM Contact WHERE Name LIKE :searchQuery LIMIT 5];
    }
}

Explanation

• @AuraEnabled(cacheable=true): This makes the method available to Lightning Components and enables caching to improve performance.
• SOQL Query: The query searches for contacts where the Name field contains the searchTerm, and we limit the results to 5 to avoid fetching too many records.

Step 2: Style the Component

You can style your component to make it visually appealing and user-friendly.

2.1 Add CSS for Typeahead Suggestions

.search-box {
    width: 100%;
}

.sugg-list {
    list-style-type: none;
    margin: 0;
    padding: 0;
    background-color: #fff;
    border: 1px solid #d8dde6;
    position: absolute;
    width: 100%;
    z-index: 10;
}

.sugg-item {
    padding: 10px;
    cursor: pointer;
    background-color: #f4f6f9;
}

.sugg-item:hover {
    background-color: #e1e5ea;
}

Explanation

• Styling: The suggestions list is styled with a simple background, padding, and hover effect to make it more interactive.

Step 3: Test Your Typeahead in Salesforce

After deploying your component, add it to a Lightning Page or a record page in Salesforce. As users start typing, they should see suggestions appear dynamically.

Enhancing User Experience

Here are some ways to enhance the user experience:

1. Debouncing: To avoid querying Salesforce on every keystroke, you can implement a debouncing technique to wait until the user stops typing for a certain period (e.g., 300ms).
2. Loading Indicator: Add a loading spinner to show users that suggestions are being fetched.
3. Error Handling: Implement user-friendly error messages if the Apex method fails or if no results are found.

Conclusion

In this blog, we’ve created a simple but effective Typeahead search functionality in Salesforce LWC. By leveraging Apex to retrieve dynamic suggestions, the component provides an interactive search experience for users, helping them find records faster and more efficiently.

This implementation adapts to various use cases, such as searching through records like Contacts, Accounts, Opportunities, or custom objects. You can customize this solution to fit your Salesforce application perfectly by understanding the key concepts and building blocks.

Happy coding, and feel free to share your feedback or improvements in the comments!

Related Resources

• Salesforce Lightning Web Components Documentation
• Apex Programming Guide

Salesforce development involves handling various data manipulation tasks, including sorting and comparing data. Two important tools in Java and Apex, which is Salesforce’s programming language, are the Comparator Interface and the Collator Class. These tools help developers efficiently compare objects, sort them, and ensure proper data handling in various use cases. They are particularly useful for processing records, displaying results, and sorting lists.

In this blog, we will be exploring the Comparator Interface and Collator Class.

What is the Comparator Interface?

The Comparator Interface is part of Java and is also implemented in Apex. It provides a way to define custom sorting logic for objects, especially when the default Comparable interface isn’t sufficient. By implementing the Comparator interface, developers can create complex sorting rules for lists, maps, or other collections, making it one of the most flexible options for sorting data.

In Salesforce, the Comparator interface is commonly used when you need to sort records based on specific business logic that goes beyond natural ordering (e.g., sorting by date, custom fields, or conditions).

How the Comparator Interface Works in Apex

In Apex, the Comparator interface is implemented by defining a method compare(Object obj1, Object obj2) that compares two objects and returns an integer based on their relative order.

• compare() method:
  • Returns a negative number if obj1 is less than obj2.
  • Returns a positive number if obj1 is greater than obj2.
  • Returns zero if obj1 and obj2 are equal.

Implementing the Comparator Interface

Suppose we have a list of Account objects, and we need to sort them based on their AnnualRevenue. Here’s how you can implement the Comparator interface to sort these accounts in descending order of AnnualRevenue.

public class AccountRevenueComparator implements Comparator {
    public Integer compare(Object obj1, Object obj2) {
        Account acc1 = (Account) obj1;
        Account acc2 = (Account) obj2;
        
        if (acc1.AnnualRevenue > acc2.AnnualRevenue) {
            return -1; // acc1 comes before acc2
        } else if (acc1.AnnualRevenue < acc2.AnnualRevenue) {
            return 1; // acc1 comes after acc2
        } else {
            return 0; // They are equal
        }
    }
}

Explanation

• compare(): This method compares the AnnualRevenue of two Account objects and returns -1, 1, or 0 depending on the comparison result.
• Sorting: You can now sort a list of Account objects using this comparator.

List<Account> accounts = [SELECT Name, AnnualRevenue FROM Account];
accounts.sort(new AccountRevenueComparator());

This will sort the accounts list in descending order based on their AnnualRevenue field.

What is the Collator Class?

The Collator Class is another important tool for comparing strings in a locale-sensitive manner. While the Comparator interface is used for comparing objects in a custom way, the Collator class is specialized for comparing text strings, mainly when dealing with internationalization (i18n) or localization (l10n) issues.

When dealing with text in different languages and regions, string comparison can become complex due to variations in alphabets, accent marks, case sensitivity, and special characters. The Collator class helps handle these variations in a more standardized and predictable way.

How the Collator Class Works in Apex

The Collator class is practical when you want to compare strings based on the rules of a specific locale, considering factors such as language and regional differences.

• The Collator class is designed to handle string comparisons in ways that reflect how people from different regions might sort or compare them. For example, some languages sort characters in different orders, and the Collator handles this appropriately.

Using the Collator Class

Let’s say you want to compare two strings based on the locale of a country or region (like fr for French, en for English). Here’s an example of how you can use the Collator class to compare strings based on locale in Salesforce:

String str1 = 'café';
String str2 = 'cafe';

// Using Collator to compare strings in French locale
Collator collator = Collator.getInstance('fr');
Integer result = collator.compare(str1, str2);

if (result == 0) {
    System.debug('The strings are considered equal.');
} else if (result < 0) {
    System.debug('The first string comes before the second string.');
} else {
    System.debug('The first string comes after the second string.');
}

Explanation

• Collator.getInstance('fr'): This retrieves a Collator instance for the French locale. This means it will compare strings according to French sorting rules.
• compare(): The method returns a negative number if the first string comes before the second, a positive number if it comes after, and 0 if they are equal.

This example is helpful when handling multilingual data in Salesforce, where string comparison is not just about alphabetic order but also about regional differences in how characters are sorted.

Comparator vs. Collator: When to Use Each

While both the Comparator and Collator classes are used for comparisons, they serve different purposes:

• Use the Comparator interface:
  • When you need to compare and sort complex objects like records (e.g., Account, Contact, or custom objects).
  • When the comparison logic depends on multiple fields or custom business logic (e.g., comparing records by a combination of fields such as revenue and date).
• Use the Collator class:
  • When comparing string data with sensitivity to locale and language-specific rules.
  • When you need to compare textual data in a way that respects the cultural nuances of sorting and comparing, such as accents, alphabetic order, or case.

Conclusion

This blog explored the powerful tools that Salesforce developers can leverage to compare and sort data: the Comparator interface and the Collator class.

• The Comparator interface is essential when working with custom sorting logic for objects in Apex, such as sorting records by custom fields or business rules.
• The Collator class is perfect for comparing strings in a way that accounts for language and regional differences, ensuring that your app provides the right results no matter the user’s locale.

By understanding and applying these two concepts, you can enhance the flexibility and functionality of your Salesforce applications, whether you’re sorting complex data or comparing strings in a multilingual context.

Happy coding, and don’t hesitate to experiment with these features to streamline your Salesforce data management processes!

Related Resources

• Understanding ‘with sharing,’ ‘without sharing,’ and ‘inherited sharing’ in Salesforce
• Salesforce Developer Documentation on Comparator
• Salesforce Developer Documentation on Collator