Common Interview Questions on Salesforce Lightning (2023) - IQCode

Overview of Salesforce Lightning Platform

Salesforce Lightning is a powerful application development platform that simplifies the tasks of business users. The Lightning Experience provides a modern user interface with advanced features and pages that streamline the sales process and help grow your business. The platform is equipped with all the necessary technologies and tools to keep the Salesforce Platform up to date. Prominent firms like Adidas, Cisco Systems, Motorola Inc, and Allianz AG use Salesforce Lightning to conduct their operations and improve customer relationships. Therefore, certified salesforce lightning professionals have many career opportunities worldwide.

Features of Salesforce Lightning

Lightning has many fascinating developer tools and features which are listed below:

• The Lightning Component Framework helps speed up app development and performance. Custom components can be created for other developers and admins to use to customize Lightning Experience and the Salesforce mobile app.
• The Lightning App Builder allows admins to create Lightning pages by visually combining off-the-shelf and custom-built Lightning components. Lightning components can be made available to the Builder, allowing admins to create bespoke user interfaces without writing code.
• The Lightning Experience Builder uses components and templates to graphically develop communities without coding. Community pages can be created without coding by making Lightning components available in the Experience Builder.

Salesforce Lightning Interview Questions for Freshers

1. Can you explain the different programming models used to develop Lightning Components?

Code:

javascript
There are two programming models available to develop lightning components:

1. Lightning Web Components: These are Create components made up of basic HTML, CSS, and JavaScript. As a result, they’re less reliant on Salesforce and more adaptable. Anyone with abilities in front-end web technology can learn them.

2. Aura Components (still supported): Aura Components use a specialized JavaScript framework and are supported by the Salesforce platform. They are more adaptable than Visualforce, allowing designers to make more high-quality applications streamlined for the Salesforce platform.

Benefits of Using the Aura Components Programming Model

The Aura components programming model provides several benefits, including:

• Improved performance of web applications by reducing the server response time with lightning-fast asynchronous server calls
• Easy development of reusable and modular components that you can plug and play in your applications, leading to faster development cycle and cleaner code
• Consistency in the look and feel of your application components, leading to a better user experience
• Easy maintenance of components with lesser debugging time, modular testing, and encapsulation

Benefits of Using Lightning Web Components (LWC) over Aura Components

There are several benefits of using Lightning Web Components (LWC) over Aura Components. Some of them are listed below:

• Performance: LWC loads faster and consumes less memory compared to Aura Components, resulting in better overall performance.
• Modularity: LWC is based on modern web standards and uses Shadow DOM to encapsulate components, making them modular and easier to maintain.
• Reusability: LWC can be easily reused across multiple projects, making it a more efficient and cost-effective choice.
• Developer Productivity: LWC has a smaller learning curve for developers as it uses standard HTML, CSS, and JavaScript, reducing development time and increasing productivity.
• Compatibility with Other Web Technologies: LWC integrates seamlessly with other web technologies, such as React, Vue.js, and Angular.

// Example of LWC Component

html
<template>
  <h1>Hello World!</h1>
</template>

// Example of Aura Component

html
<aura:component>
  <h1>Hello World!</h1>
</aura:component>

Explanation of How the Aura and Lightning Web Framework Coexist Together

Both the Aura framework and the Lightning web framework are programming models that allow developers to create web applications using Salesforce. While Aura is a component-based framework, Lightning is an event-driven framework.

In terms of coexistence, the two frameworks can be integrated together for the same application. With Salesforce's Lightning Components, Aura components can be used alongside Lightning Components. Additionally, when a Lightning Component is created, it can also use Aura components. This means that developers have the flexibility to choose which framework they prefer to use for each component of their application, based on their functionalities and requirements.

Furthermore, Salesforce Lightning Experience is built on top of the Lightning web components framework. Aura components can still be used in the Lightning Experience, but as far as new Salesforce features going forward, Lightning web components are the main framework for creating new Salesforce features, thus protecting the investment of the community and enabling developers to create cutting-edge functionality for Salesforce users.

In conclusion, both Aura and Lightning web frameworks can be used together in the same application, providing a seamless user experience. Developers can choose which framework to use for each component of their application and still make the application efficient and effective.

Salesforce Lightning Events: Types and Descriptions

Lightning Events are used in Salesforce Lightning to communicate between different components. There are three types of events:

- Component Events: Used to communicate between components within a single framework.
- Application Events: Used to communicate between components that are not directly related.
- System Events: Handled by the framework and used to communicate about system-level changes.


Each event has a unique structure and can contain data that needs to be passed between components. Understanding the different types of events and how to use them is important for building efficient and effective Salesforce Lightning components.

Understanding Lightning Data Service (LDS) in the context of Salesforce Lightning

LDS is a powerful tool within the Salesforce Lightning framework. It allows developers to retrieve, modify, and save data on the client-side without the need for server round trips. By leveraging LDS, developers can build highly responsive and efficient Lightning applications.

LDS provides a convenient way to access and manipulate data using Lightning components. As a result, it helps to reduce the amount of custom code that developers need to write. LDS is particularly useful when building complex and dynamic user interfaces that require frequent data updates.

One of the key benefits of LDS is that it automatically handles data synchronization between the client and the server. This means that developers can focus on building their applications rather than worrying about data management.

Overall, Lightning Data Service is a powerful tool that can help developers build responsive, efficient, and scalable applications within the Salesforce Lightning framework.

Understanding the Salesforce Lightning Design System (SLDS)

The Salesforce Lightning Design System (SLDS) is a set of design standards and guidelines that can be used to develop consistent and responsive interfaces for Salesforce applications. It provides a framework for creating custom UI components that match the design language of Salesforce products. The SLDS also supports accessibility and mobile devices responsiveness, making it an ideal option for designing applications on a variety of devices. Overall, the SLDS enables developers to create visually pleasing and functional apps while maintaining an intuitive user experience.

Benefits of Using Salesforce Lightning Design System (SLDS)

Salesforce Lightning Design System (SLDS) provides the following benefits:

1. Consistency: SLDS ensures consistency in the design of user interfaces across different devices and platforms.
2. Speed: Its pre-built components and design assets help in rapid development and time-to-market.
3. Accessibility: It follows accessibility standards and guidelines to ensure that all users, including those with disabilities, can use the application.
4. Flexibility: Developers can customize the design system to match their brand identity and design requirements.
5. Community-driven: SLDS is supported and maintained by a community of developers, which ensures its continuous improvement and development.

Overview of Salesforce Lightning Experience

Salesforce Lightning Experience is a platform on the Salesforce CRM system that enables professionals to work more efficiently, be more productive, and provide better customer service. It provides a modern, streamlined interface that allows users to navigate quickly and efficiently through the system. Salesforce Lightning Experience represents a significant step up from the classic Salesforce interface and is designed to help improve user productivity, collaboration, and provide a personalized user experience. It is highly recommended for Salesforce users to switch to Lightning Experience to enjoy the benefits it offers.

CORE PRINCIPLES OF SALESFORCE LIGHTNING UI

Salesforce Lightning UI is based on the following core principles:

• Faster Performance: Efficiently designed to give a faster and immersive user experience to increase productivity.
• Consistency and Clarity: Provide a consistent and clear design to ensure that users can navigate and use the application with ease.
• Intelligence: Enable users to gain more detailed insights into their data with the help of smart features and artificial intelligence.
• Productivity: Increased productivity by providing quick access to relevant and important information.

Following these principles, Salesforce Lightning UI offers a modern, intuitive, and customizable user interface for salesforce applications.

Types of Component Bundles for Lightning Components

In Lightning Components, there are three types of component bundles:

• aura:component bundle: It contains a single Lightning component.
• aura:application bundle: It contains a set of Lightning components that act as an application.
• aura:library bundle: It contains a set of reusable Lightning components that can be used across applications.

Can a Lightning Component be Connected to Another Component?

Yes, it's possible to connect/link one Lightning component to another within the same or different Lightning applications. This is achieved by defining attributes in the parent component that are set to values in the child component. These values can be used in the parent component's markup and controller.

Bound and Unbound Expressions in Salesforce Lightning

Salesforce Lightning uses expressions to dynamically display data and control the behavior of components. These expressions can be either bound or unbound.

Bound expressions are those that are dynamically bound to a component's properties and can dynamically update the view. These expressions are enclosed in double curly braces, for example, {{myComponentProperty}}.

Unbound expressions, on the other hand, are expressions that do not rely on a component's properties and do not update the view dynamically. These expressions are enclosed in single curly braces, for example, {!ControllerMethod}.

Understanding the difference between bound and unbound expressions is crucial for building dynamic and responsive Salesforce Lightning components.

Salesforce Constraints on Maximum Number of Components per App

As per Salesforce, there are limits to the maximum number of components per app. The limit varies depending on the type of component. For example, a Lightning web component can have a maximum of 200 components per app, whereas a Visualforce page can have up to 500 components per app. It is important to keep these constraints in mind while developing apps in Salesforce to ensure that the app functions smoothly without hitting any limits.

Can Lightning be integrated with a third-party framework?

Yes, it is possible to integrate Lightning with a third-party framework. However, the level of integration can vary depending on the specific framework being used. The integration can be done using JavaScript libraries or by making API requests to the Lightning server. It is important to thoroughly research and test the integration to ensure that it is seamless and does not cause any conflicts with existing functionality.

Can Aura Components be used with Lightning Web Components and vice versa?

Yes, it is possible to use Aura Components with Lightning Web Components and vice versa. They can coexist within an application and can communicate with each other using events and interfaces. However, it is recommended to migrate to Lightning Web Components as they offer better performance, improved programming model, and enhanced security features.

Purpose of using Lightning's aura:method tag

The aura:method tag in Lightning is used to define a method in a component's controller that can be called from other components. It facilitates the communication between components in a Lightning application. By using aura:method, a developer can expose a method to other components which can then call that method to perform a specific action, passing data if necessary. This reduces the need to duplicate code across components and provides an effective method of creating reusable components.

Can a Lightning Component be used for both mobile and desktop interfaces?

Yes, it is possible to use a Lightning Component that can work with both mobile and desktop interfaces. This type of component is called a responsive component. In order to create a responsive component, you will need to use the appropriate CSS media queries and make sure that the component is designed with a flexible layout. By doing so, the component will be able to adjust its layout based on the device and screen size that it is being viewed on. This will ensure that the component will work effectively with both desktop and mobile interfaces.

Attributes in Salesforce Lightning

In Salesforce Lightning, attributes are variables that are defined at the component level and hold data that can be used by the component or passed down to its child components. These attributes define the inputs and outputs of a component and are defined in the component's XML file.

The parameters that must necessarily be provided when defining an attribute are:

1. Name – This is the unique identifier for the attribute within the component. 2. Type – This is the data type of the attribute (e.g., String, Integer, Boolean). 3. Default – This is the initial value of the attribute. 4. Access – This determines whether the attribute is public or private. 5. Description – This provides a brief description of the attribute and its purpose.

Properly defining attributes is crucial in building efficient and effective Lightning components in Salesforce.

Options for Debugging Components

There are several options available to debug components in our project:

1. Using console.log() statements at key points in the component to log values and check for errors.
2. Using the React Developer Tools browser extension to inspect the state and props of components.
3. Using the debugger statement in the code to pause execution and examine the state of the component at that point.
4. Using breakpoints in the browser's developer tools to pause execution at specific lines of code and examine the state of the component.
5. Using the React Profiler to identify performance issues and optimize the component.

It's important to use a combination of these options to effectively debug and optimize our components.

Understanding Lightning Navigation in Salesforce

In the context of Salesforce Lightning, Lightning Navigation refers to the optimized and efficient way of working within the Lightning Experience. It involves using features such as the App Launcher, Lightning pages, and Lightning Components to navigate quickly and seamlessly through the platform. By leveraging Lightning Navigation, users can improve productivity, save time, and enjoy a more intuitive and modern user experience.

Which Interface to Use for Retrieving Record ID from Record Detail Page?

To retrieve a record's ID from the record detail page, you should use the Salesforce interface called "getRecordId()". This interface is available in all Visualforce pages and Lightning components in Salesforce. Once you retrieve the record ID, you can then use it to perform various operations on the record, such as updating or deleting it.

Salesforce Lightning Interview Questions for Experienced

Question 23: Can you explain what Lightning Out is in the context of Salesforce Lightning?

Lightning Out

is a feature in Salesforce Lightning that allows you to use your Lightning Components outside of the Salesforce platform. It is primarily used to run Lightning Components on your external website or web apps. With Lightning Out, the Lightning Components can be embedded into any web page with only a few lines of code without needing to be in the Salesforce platform. This way, you can use existing components to build apps that can run on non-Salesforce sites.

Explaining the Propagation of Component Events in Salesforce Lightning

In Salesforce Lightning, a component event is first fired in the component where it was originally triggered. From there, it can propagate up the component hierarchy or down to its child components, depending on how it was designed to behave.

If the event is meant to propagate up, the parent component can handle the event and perform any necessary actions. Alternatively, if the event is meant to propagate down, the child components can handle the event and perform the necessary actions.

To enable this behavior, Salesforce Lightning uses the application event and component event models. The former allows events to propagate across the entire application, while the latter allows events to be restricted to a specific component hierarchy.

By using component events in Salesforce Lightning, developers can achieve more modular and efficient designs for their applications, which can result in faster development times and better user experiences.

Application Event Propagation in Salesforce Lightning

In Salesforce Lightning, an application event is created by the event producer and is handled by one or more event consumers. When an application event is fired, it propagates upwards from the event producer to the ancestor component hierarchy until a handler for the event is found.

The event propagation process in Salesforce Lightning consists of three phases: capture, bubbling, and default. During the capture phase, the event is dispatched to the component hierarchy in a top-down order, starting from the root component of the application.

During the bubbling phase, the event is dispatched in a bottom-up order, starting from the component that is closest to the event producer and moving upwards to the root component.

If the event is not handled during the capture and bubbling phases, it enters the default phase, which allows any component to handle the event.

Overall, application events in Salesforce Lightning provide a flexible and efficient way for components to communicate with each other in a decoupled manner, allowing for greater flexibility and maintainability in the application architecture.

Difference between Component Events and Application Events in Salesforce Lightning

In Salesforce Lightning, Component Events and Application Events are two types of events used for communication between components. Component Events are specific to the component they are fired from and can only be handled by the parent component or its ancestors. On the other hand, Application Events are handled by any component that has registered to handle the event, regardless of their hierarchical relationship.

In simple words, Component Events are used for communication between a parent and its child components, while Application Events are used for communication between unrelated components. Therefore, it is necessary to choose the appropriate event type based on the communication requirements between your components.

Differences between Salesforce Classic and Salesforce Lightning

Salesforce Classic and Salesforce Lightning are two different user interfaces provided by Salesforce. Salesforce Classic is the original interface, while Salesforce Lightning is the modern and updated version.

One of the key differences between the two is the visual appearance. Salesforce Classic has a simple and traditional look, while Salesforce Lightning has a more modern and visually appealing interface.

Another difference between the two is the feature set. Salesforce Lightning offers a variety of new features that are not available in Salesforce Classic. For example, Lightning Experience has a more intuitive interface and advanced dashboards.

Salesforce Lightning is also optimized for use on mobile devices, with responsive design and additional mobile-focused features.

Overall, Salesforce Lightning is the more advanced and modern of the two interfaces, while Salesforce Classic is more traditional and simpler to use. However, both interfaces can be used to access the same Salesforce data and features, depending on your preferences and needs.

Understanding Visualforce and how it differs from Salesforce Lightning

Visualforce is a framework provided by Salesforce that allows developers to build custom user interfaces for applications built on the Salesforce platform. Visualforce pages use a combination of HTML, Apex, and JavaScript to generate dynamic content that can be displayed in a web browser.

Salesforce Lightning, on the other hand, is a modern user interface for the Salesforce platform. It is built using a component-based architecture that makes it easy to create reusable UI components. Lightning also includes features like the Lightning App Builder, which allows non-technical users to create custom pages and apps using a drag-and-drop interface.

One of the key differences between Visualforce and Salesforce Lightning is their approach to UI development. Visualforce requires developers to write all of their UI code manually, whereas Lightning provides a set of pre-built components that can be assembled to create custom pages and apps.

Another difference is that Lightning is designed with mobile in mind, while Visualforce was originally built for desktop browsers. This means that Lightning provides better support for responsive design and mobile-specific features like touch gestures.

Overall, while Visualforce is still a viable option for building custom UIs on the Salesforce platform, Lightning offers a more modern and flexible approach to UI development.

Understanding Lightning Pages in Salesforce Lightning

In the context of Salesforce Lightning, Lightning Pages are a modern and flexible way to display information and functionality in the Salesforce user interface. They provide a drag-and-drop interface for building custom user interfaces, making it easy to customize the look and feel of Salesforce apps.

Lightning Pages can be used to build Home Pages, Record Pages, App Pages, and other types of pages in Salesforce Lightning. They are highly customizable and can be tailored to the needs of specific users or groups, improving productivity and user experience.

Lightning Pages are built using Lightning components, which are reusable building blocks of Salesforce functionality. These components can be combined to create custom pages that meet specific business requirements. Overall, Lightning Pages are a powerful tool for building custom user interfaces in Salesforce Lightning, improving productivity and enhancing the user experience.

Different Types of Lightning Pages Available in Salesforce Lightning

In Salesforce Lightning, there are four types of pages available:

1. Home Pages - used as the landing page for an app or specific object.

2. Record Pages - used to display a single record and its related information.

3. App Pages - used to build custom app pages by adding Lightning components.

4. Utility Pages - used to add productivity tools or components to a user’s workspace outside of a specific record or object context.

Understanding FlexiPage in Salesforce Lightning

FlexiPage in Salesforce Lightning is a type of page layout that allows users to customize their Salesforce experience by adding, removing, and rearranging components on a page. With FlexiPage, users can create personalized pages that display only the information they need, helping them work more efficiently and effectively. FlexiPage can be used for a variety of purposes, from displaying customized dashboards to creating unique record detail pages. It is a powerful tool that allows users to tailor their Salesforce experience to their specific needs.

Understanding the Difference between force:lightningQuickAction and force:lightningQuickActionWithoutHeader in Salesforce Lightning Component

In the Salesforce Lightning Component, the main difference between

force:lightningQuickAction

and

force:lightningQuickActionWithoutHeader

is that the former displays the component with the standard header while the latter doesn't.

force:lightningQuickAction

displays the component within a modal dialog with a standard header that includes a title and a close button. On the other hand,

force:lightningQuickActionWithoutHeader

displays the component without a header, hence providing a relatively larger real estate for the content.

When deciding which to use, consider the layout of the component and the user experience. If the component requires a header, then use

force:lightningQuickAction

. Otherwise, use

force:lightningQuickActionWithoutHeader

.

Salesforce Lightning Interview Question: Keeping an Application Running While Deactivating a Specific User

In the scenario where a specific user needs to be deactivated but the application should still remain active, the most practical solution would be to reassign the user’s responsibilities to another user. This can be done by creating a new user and transferring the necessary data to that new user's account. It is important to ensure that all of the deactivated user’s tasks, events, leads, cases, and opportunities are reassigned to the new user. This will allow the application to continue functioning without any interruptions. Additionally, any scheduled reports or dashboards should also be updated to reflect the changes.

Use of Controller and Controller extension

We have two types of controllers, regular and extension controllers. In our codebase, most of the logic is implemented in the controller extension. This controller extension is sometimes written in a custom controller or not.

// Sample code for Controller Extension public with sharing class CustomControllerExtension {

// code implementation

}

Can multiple users have similar profiles? Will a user be assigned two profiles?

In the system, it is possible for two users to have similar profiles. However, a single user cannot be assigned multiple profiles. Each user is only allowed to have one unique profile in the system.

Creating a Master-Detail Relationship between Two Unlinked Objects

Suppose you have two objects named Object1 and Object2 that are not currently linked to each other, and you need to establish a master-detail relationship between them. Is this possible? Yes, it is possible.

To do so, follow these steps:

1. Identify a field in the child object (Object2) that you can create a lookup relationship with the parent object (Object1). 2. Create a new field in Object2 that will store the values from the selected field in Object1. 3. Create a lookup relationship between Object1 and the newly created field in Object2. 4. After the lookup relationship has been established, you can convert the lookup relationship to a master-detail relationship.

Once the master-detail relationship has been established, any changes made to the parent record (Object1) will cascade down to the child record (Object2).

Note that this process can vary based on the specific objects and fields involved, and the steps listed above may need to be modified accordingly.

How to Create a Many-to-Many Relationship in Salesforce?

To create a many-to-many relationship in Salesforce, you need to create a junction object that serves as a bridge between the two objects you want to relate. Follow the steps below to create a many-to-many relationship:

1. Identify the objects: Identify the two objects you want to relate together. For example, if you want a many-to-many relationship between Accounts and Contacts, then these are the two objects you need to identify.

2. Create a junction object: Create a custom object that will serve as the junction between the two objects you identified. For example, you can create an object called "AccountContactJunction" that will serve as the junction between Accounts and Contacts.

3. Create two master-detail relationships: Create two master-detail relationships on the junction object that point to the two objects you want to relate. For example, create a master-detail relationship on the junction object that points to both Accounts and Contacts.

4. Update fields: Update the fields on the junction object to show the related records. For example, you can add a lookup field to point to the Account and Contact object, respectively.

5. Add the related list: Finally, add a related list to the detail page layout for both objects so that you can see the related records. The related list will show the records that are connected to the junction object.

By following these steps, you can create a many-to-many relationship in Salesforce. This will allow you to relate two objects together in a way that wasn't possible before and make your data more organized and manageable.