Update : ✨ Agentforce Batch - Starts 23rd Oct 2025, 8 AM IST || ✨ Admin & Dev Batch - Starts 22nd Oct 2025, 6 PM IST | Contact us for more info +91 - 709 7777 111
X

About Us

Welcome to Salesforce, where we specialize in empowering professionals with cutting-edge Salesforce training.

Contact now

Contact Info

  • CV Complex,
    Above Bata Showroom,
    Hastinapuram, BN Reddy,
    Hyderabad, Telangana 500079.
  • +91-7097777111
  • info@sfdcindia.com

Development - LWC

  • Course Content
  • Overview

Automates business processes and modern web components.

Apex Overview

What is Apex?

Apex is Salesforce’s proprietary programming language used to build custom business logic. It is strongly typed, object-oriented, and works seamlessly with the Salesforce database. Apex enables developers to write triggers, classes, batch jobs, and web services for complex business requirements.

Who Can Learn Apex?

Apex is best suited for developers or admins with basic programming knowledge (Java, C#, or similar). It’s useful for those wanting to extend Salesforce with advanced automation and integrations beyond what clicks and flows can achieve.

Do We Need Apex Always?

No. Many tasks can be achieved with declarative tools like Flows and Validation Rules. Apex is required when logic is complex — for example, multi-step calculations, real-time integrations, or bulk data operations.

Real-World Uses

Apex is used for triggers (e.g., auto-creating invoices when an opportunity closes), batch jobs (e.g., nightly data cleanup), and API integrations (e.g., syncing Salesforce with ERP or payment systems).

Why It’s Important

Apex powers advanced business logic and integrations, enabling Salesforce to handle enterprise-level customizations. It’s essential for Salesforce Developers, Architects, and Integration Specialists.

LWC (Lightning Web Components) Overview

What is LWC?

Lightning Web Components (LWC) is Salesforce’s modern UI framework based on web standards like HTML, JavaScript, and CSS. It allows developers to build fast, reusable, and responsive UI components inside Salesforce Lightning.

Who Can Learn LWC?

LWC is ideal for front-end developers and Salesforce professionals familiar with HTML and JavaScript. Admins and Developers can learn LWC to enhance user experience and build custom Lightning pages.

Do We Need LWC Always?

Not always. Standard Lightning components often meet business needs. But when companies need custom UI/UX like guided forms, dynamic dashboards, or integration panels, LWC becomes necessary.

Real-World Uses

LWC is used for building interactive dashboards, custom wizards, and integrated panels (e.g., displaying live shipment status from a logistics API). It gives end users a modern, app-like experience.

Why It’s Important

LWC is the future of Salesforce UI development. It ensures performance, reusability, and modern design. Mastering LWC opens career paths as Salesforce Developers, UI/UX Specialists, and Technical Architects.

Development - LWC

  • 45 sessions
  • Apex Session 01

    Introduction to Apex Programming

    • Introduction to Apex and execution methods
    • Developer Console & Execute Anonymous overview
    • Apex data types: Primitive and sObject
    • Variable declaration and debug statements
    • Common scenarios and hands-on examples
  • Apex Session 02

    Introduction to Operators and Conditions

    • Overview of Apex operators
    • Arithmetic, relational, and assignment operators
    • Increment/decrement and logical operators
    • Conditional statements: if, else, else if, nested if
  • Apex Session 03

    Looping

    • Introduction to loops and arrays in Apex
    • Loop types: while, do-while, for loop
    • Enhanced for loop usage
    • Declaring and using arrays
    • Scenarios based examples
  • Apex Session 04

    Introduction to OOPs

    • Introduction to Apex keywords
    • Overview of Object-Oriented Programming (OOP)
    • Static vs non-static in Apex
    • Classes, objects, and constructors
    • Real-time OOP examples in Apex
  • Apex Session 05

    Introduction to Access Specifiers

    • Introduction to classes in Apex
    • Creating and instantiating objects
    • Purpose of access specifiers
    • Types: public, private, global, protected
    • Access specifiers in real use cases
  • Apex Session 06

    Collections in Apex

    • Introduction to collections in Apex
    • Overview and use of List collection
    • Creating and initializing lists
    • List prebuilt methods
    • Looping through list elements
  • Apex Session 07

    Collections – Set and Map

    • Introduction to Set and Map collections
    • Set – unique, unordered values
    • Map – key-value pair structure
    • Creating and initializing Sets and Maps
    • Prebuilt methods for Set and Map
  • Apex Session 08

    SOQL (Salesforce Object Query Language)

    • Introduction and basic SOQL syntax
    • Ways to run SOQL queries (Apex, Developer Console, Workbench)
    • Using WHERE, GROUP BY, HAVING clauses
    • Common SOQL functions (COUNT, AVG, SUM, MIN, MAX)
    • Real-time scenarios and best practices
  • Apex Session 09

    Dynamic SOQL

    • ORDER BY, LIMIT, OFFSET, ALL ROWS, FOR UPDATE
    • Types of SOQL queries in Apex
    • Static vs dynamic SOQL syntax
    • Building dynamic queries safely
  • Apex Session 10

    Relationship Query

    • Intro to SOQL relationship queries
    • Parent-to-child queries (standard objects)
    • Child-to-parent queries (standard objects)
    • Custom object relationships in SOQL
    • Introduction to SOSL and its use cases
  • Apex Session 11

    DML (Data Manipulation Language)

    • DML intro – atomic vs non-atomic
    • Use insert, update, delete, upsert
    • Use Database methods for control
    • Handle results with SaveResult
    • Check success with isSuccess(), getId()
    • Catch errors using getErrors()
  • Apex Session 12

    Email Programming

    • Overview of email programming in Salesforce
    • Types of email services (inbound & outbound)
    • Outbound email using SingleEmailMessage
    • Sending bulk with MassEmailMessage
    • Inbound email using InboundEmail class
    • Use of Messaging.InboundEnvelope in processing
  • Apex Session 13

    Introduction to Wrapper Classes

    • Introduction to wrapper classes in Apex
    • Why and when to use wrappers
    • Creating a custom wrapper class
    • Using wrappers in Visualforce/LWC
    • Iterating wrapper lists in controller
    • Real-time use cases and best practices
  • Apex Session 14

    Introduction to Apex Triggers

    • Introduction to Apex Triggers
    • Trigger events: before/after insert, update, delete
    • Syntax and trigger structure
    • Trigger context variables
    • Use cases for real-time automation
  • Apex Session 15

    Apex Triggers – Part 2

    • Create a before insert trigger
    • After update use case (e.g., log changes)
    • Prevent recursive triggers
    • Add business logic with SOQL/DML
    • Testing basic trigger functionality
  • Apex Session 16

    Apex Triggers – Part 3

    • One trigger per object pattern
    • Using handler classes for logic
    • Avoiding SOQL/DML inside loops
    • Error handling and debug logging
    • Versioning and naming conventions
  • Apex Session 17

    Apex Triggers – Part 4

    • Deactivating a trigger
    • Deleting a trigger
    • Order of execution for triggers
    • Best practices for writing triggers
  • Apex Session 18

    Apex Test Class

    • Overview of test classes and creation
    • Ways to write test classes
    • How to run test classes
    • Test methods and annotations
  • Apex Session 19

    Apex Test Class – Part 2

    • Use of @isTest annotation
    • Create test data vs SeeAllData
    • Use startTest() and stopTest()
    • Assert with System.assert()
    • Use test utility classes
    • Code coverage requirement (75%)
  • Apex Session 20

    Asynchronous Apex

    • Introduction to asynchronous processing in Apex
    • Batch Apex – large data processing
    • Scheduled Apex – running jobs at specific times
    • Future methods – syntax and use cases
    • Queueable Apex – chaining and job handling
  • Apex Session 21

    Batch Apex

    • Introduction to Batch Apex and its use
    • Implementing Database.Batchable interface
    • Methods: start(), execute(), finish()
    • Running and monitoring batch jobs
    • Use cases and best practices
  • Apex Session 22

    Scheduled Apex & Future Methods

    • Introduction to Scheduled Apex
    • Implementing the Schedulable interface
    • Writing the execute() method
    • Scheduling with System.schedule()
    • Monitoring scheduled jobs in Setup
    • Introduction to @future annotation
    • When to use future methods
    • Best practices and real-time use cases
  • Apex Session 23

    Queueable Apex & Flex Queue

    • Introduction to Queueable Apex
    • Implementing Queueable interface and execute()
    • Chaining multiple queueable jobs
    • When to use Queueable over Future methods
    • Overview of Flex Queue (holds 100 jobs)
    • Managing and monitoring jobs in Apex Flex Queue
  • Apex Session 24

    Apex Debugging

    • Introduction to Apex debugging
    • Enable debug logs in Setup
    • Set log levels and monitored users
  • Apex Session 25

    Introduction to LWC & LWC Setup

    • Introduction to Lightning Web Components (LWC)
    • LWC vs Aura – key differences
    • LWC folder structure and file types
    • Setting up Salesforce DX and VS Code
    • Creating and deploying your first LWC
    • Real-time use cases and benefits of LWC
  • LWC Session 26

    HTML Basics

    • Introduction to HTML and its structure
    • Common tags vs Lightning tags
    • Forms and input elements
    • Lists, tables, and layout tags
    • HTML attributes and nesting rules
    • Use of HTML in LWC templates
  • LWC Session 27

    CSS Basics

    • Introduction to CSS and its purpose
    • Types: Inline, Internal, External CSS
    • Common properties: color, font, margin, padding
    • CSS selectors: class, ID, element
    • Styling HTML elements in LWC
    • Best practices for clean, reusable CSS
  • LWC Session 28

    JavaScript Essentials

    • Introduction to JavaScript and its role in web apps
    • Variables (let, const, var) and data types
    • Operators and expressions
    • Conditional statements: if, else, switch
    • Loops: for, while, do-while
  • LWC Session 29

    JavaScript Essentials

    • Defining and calling functions
    • Parameters and return values
    • Arrow functions (=>)
    • Variable scope (global, local, block)
    • Working with objects and key-value pairs
  • LWC Session 30

    Functions in JavaScript

    • Introduction to functions and their purpose
    • Defining functions using function keyword
    • Calling and executing functions
    • Function parameters and return values
    • Arrow functions (=>) vs regular functions
    • Scope of variables inside functions
    • Real-time use cases in LWC
  • LWC Session 31

    Data Binding in LWC

    • Introduction to data binding in LWC
    • One-way binding using template expressions
    • Two-way binding with @track (legacy) and reactive variables
    • Using @api for parent-to-child binding
    • Event handling for child-to-parent communication
    • Real-time examples with input and output fields
  • LWC Session 32

    Lightning Input Components

    • Introduction to lightning-input component
    • Common types: text, number, email, checkbox
    • Handling input change events
    • Validating input fields in LWC
    • Binding input values to JavaScript variables
    • Real-time form example using lightning-input
  • LWC Session 33

    Lightning Buttons

    • Introduction to lightning-button and basic usage
    • Button types and event handling
    • Button controls and grouped buttons (lightning-button-group)
    • Using lightning-button-menu for dropdowns
    • Working with lightning-menu-item options
    • Real-time examples: actions, menus, and UI control
  • LWC Session 34

    Lightning Card

    • Using lightning-card for structured UI
    • Slots: title, body, footer
    • Styling and nesting components inside cards
  • LWC Session 35

    Tab Controls

    • Using lightning-tab and lightning-tabset
    • Custom labels, icons, dynamic content
    • Handling tab change events
  • LWC Session 36

    HTML Events & Browser Events

    • Standard HTML events: click, input, change
    • JavaScript event handling
    • Using addEventListener, event.target, preventDefault()
  • LWC Session 37

    Decorators in LWC

    • @api, @track, and @wire
    • Use cases and differences
    • Reactive variables and public properties
  • LWC Session 38

    Component Communication – Part 1

    • Parent to child communication using @api
    • Passing data and invoking methods
  • LWC Session 39

    Component Communication – Part 2

    • Child to parent communication
    • Dispatching and handling custom events
    • Event bubbling and composition
  • LWC Session 40

    Toast Messages

    • Using ShowToastEvent
    • Different toast types: success, error, warning
    • Custom messages and duration
  • LWC Session 41

    Lightning Data Service (LDS) – Overview

    • What is LDS and why use it
    • Benefits over Apex calls
    • Introduction to UI API
  • LWC Session 42

    Record View Form

    • Using lightning-record-view-form
    • Displaying record data without Apex
    • Nested lightning-output-field components
  • LWC Session 43

    LDS with User Interface API

    • Record and object metadata using @wire
    • getRecord, getFieldValue, getObjectInfo
    • Real-time read-only use cases
  • LWC Session 44

    LDS – Advanced

    • Using lightning-record-form, edit-form, view-form
    • Combining LDS forms with custom logic
    • Validation and error handling
  • LWC Session 45

    Lifecycle Hooks

    • Lifecycle flow in LWC
    • constructor, connectedCallback, renderedCallback, disconnectedCallback
    • Practical use cases for hooks
Course Categories