113 posts tagged with "salesforce"
Practical frameworks for making tough architecture decisions — weighted matrices, reversible vs irreversible decisions, Architecture Decision Records, and knowing when good enough beats perfect.
The quirky exceptions and limitations of Salesforce standard objects that every architect must know — Quick Actions, Queue ownership, CRUD restrictions, Lookup limitations, and Dynamic Forms compatibility.
How to calculate, monitor, and manage Salesforce data storage — per-record sizes, storage allocation, objects that don't count, and strategies for keeping storage under control.
A comprehensive guide to Salesforce security architecture — implicit sharing, roles vs territories, team sharing, data skew prevention, guest user security, and standard object sharing limitations.
Essential networking concepts every Salesforce Architect needs to know — LANs, WANs, IP addresses, subnets, firewalls, DMZs, proxies, and how they all connect to Salesforce integration design.
How to choose between Salesforce Reports, CRM Analytics, and Tableau — understanding when each tool is the right fit based on data complexity, volume, and business needs.
How to handle massive data migrations into Salesforce — choosing the right tools, preventing data skew, ensuring data quality, and testing strategies for large-scale loads.
What Salesforce governance is, why it matters as your org scales, the key governance areas every architect must address, and how to build and staff a Center of Excellence.
How to choose the right mobile strategy for Salesforce — comparing the Salesforce Mobile App, Mobile Publisher, custom apps with Mobile SDK, and PWAs with practical decision criteria.
A deep dive into OAuth authentication flows, Salesforce integration patterns, Enterprise Service Buses, TLS/mTLS, and choosing between Platform Events and Change Data Capture.
A practical framework for deciding when to use out-of-the-box Salesforce features versus custom development — understanding the true cost of customization and the 80/20 rule.
How to choose between a single Salesforce org and multiple orgs — weighing data isolation, compliance, cost, complexity, and when Salesforce Connect bridges the gap.
A practical guide to project estimation for Salesforce Architects — accounting for all team roles, managing expectations, estimating to median talent, and a hands-on estimation exercise.
How to hire the right Salesforce developers, lead through servant leadership, train your team effectively, and why your role as architect is to serve — not boss — your team.
Why communication is the most critical skill for Salesforce Architects — how to talk to stakeholders, ask the right discovery questions, set realistic expectations, and build lasting trust.
A complete guide to diagramming for Salesforce Architects — system architecture diagrams, ERDs, sequence diagrams, activity diagrams, and more, with tool recommendations and a hands-on project.
What a Salesforce Architect actually does, how the role differs from a developer, the different types of architect certifications and specializations, and the best resources to start your architecture journey.
The ultimate LWC project — build your own Salesforce portfolio as an Experience Cloud site using custom Lightning Web Components, showcasing everything you have learned in this series.
A guide to the most useful APIs available to Lightning Web Components — the Refresh View API, GraphQL API, FileDownload API, Location Services, Barcode Scanner, Document Scanner, NFC Service, Biometric Service, and AppReviewService.
A complete guide to unit testing Lightning Web Components with Jest — setup, writing basic tests, beforeEach and afterEach, testing events, conditional rendering, iterators, wire adapters, Apex calls, child components, and CI/CD integration.
How to build Lightning Web Components that work on mobile — understanding mobile readiness, designing for mobile, setting up responsive CSS, and leveraging dynamic template rendering for mobile layouts.
How to leverage client-side storage in Lightning Web Components — browser cache, cookies, and the Salesforce platform cache to improve performance and user experience.
How to integrate Lightning Web Components with Flows — building LWCs for screen flows, embedding flows inside LWCs, useful scenarios, and a project building a multi-screen flow with reusable dynamic components.
How to build Lightning Web Components for quick actions and global actions — understanding action types, creating screen actions, handling record context, and a project building a reusable case creation action.
How to create reusable JavaScript modules for LWC and how to import third-party JavaScript libraries as static resources into your Lightning Web Components.
A complete guide to the LWC Navigation Service — how to set it up, and an overview of every pageReference type for navigating to records, objects, apps, tabs, web pages, and more.
How to make your LWC configurable and placeable — design attributes for admin configuration, targeting to control where components appear, and adding custom SVG icons to your components.
How to debug Lightning Web Components — enabling the Lightning debugger, using console logging effectively, setting breakpoints in the browser console, and common debugging strategies.
A complete guide to exception handling in Lightning Web Components — try-catch blocks, throwing and creating custom errors, toast notifications, building a reusable error handling module, promise failures, and handling Apex exceptions.
How to call Apex from Lightning Web Components — imperative Apex calls, the wire service, refreshApex, sending SObject data from LWC to Apex, and proper exception handling for Apex calls.
A complete guide to the Lightning Data Service — retrieving records, the Lightning Record View Form, Record Edit Form, Record Form, intercepting form submissions, and the full uiAPI for creating, updating, and deleting records.
A complete guide to styling Lightning Web Components — the Salesforce Lightning Design System, SLDS custom variables and global styling hooks, using SLDS in your LWC, creating CSS files, reusable CSS, and using static resources for styling.
A guide to the Lightning Web Component Library — what it is, when to use library components vs building your own, how to extend base components like lightning-datatable, and a project building a data entry form with library components.
Mastering component communication in LWC — custom events for child-to-parent communication, public methods and properties for parent-to-child, the Lightning Message Service for cross-component communication, and platform events via the empAPI.
Deep dive into LWC templates — data binding, getters and setters, dynamic rendering with lwc:if, for:each iteration, the render method, component composition, lwc:spread, slots, and the slot change event.
Understanding LWC lifecycle hooks and decorators — constructor, connectedCallback, renderedCallback, disconnectedCallback, errorCallback, and the @api, @wire, and @track decorators with practical examples.
XML fundamentals for Lightning Web Components — what XML is, the structure of LWC metadata XML files, configuring targets, design attributes, and a complete XML cheat sheet.
JavaScript fundamentals for Lightning Web Components — classes, variables, data types, JSON, methods, the this keyword, DOM interaction, collections, operators, conditionals, modules, async programming, promises, destructuring, spread operator, exception handling, events, and debugging.
CSS fundamentals for Lightning Web Components — what CSS is, essential styling concepts for LWCs, how CSS scoping works in Shadow DOM, and how to debug CSS in the browser console.
HTML fundamentals for Lightning Web Components — what HTML is, the essential elements and attributes you need for building LWCs, and how to debug HTML in the browser console.
Understanding the DOM for Lightning Web Components — what the DOM is, the difference between Light DOM, Shadow DOM, and Synthetic Shadow DOM, and how Lightning Locker Service and Lightning Web Security work.
An introduction to Lightning Web Components — what they are, when to use LWC vs Aura, when to build custom components vs using out-of-the-box tools, frontend vs backend code, setting up your org, creating your first LWC, and placing it on a page.
A guide to the most valuable open source libraries in the Salesforce ecosystem — Apex Common, Apex Mocks, Universal Mocker, Nebula Logger, Apex Rollup, open source trigger frameworks, and a hands-on project using Apex Rollup.
A complete guide to CI/CD for Salesforce — what CI/CD is, what to include in your pipeline, popular tools, an introduction to YAML and shell scripting, and a hands-on project building a pipeline with GitHub Actions.
A complete guide to Unlocked Packages — what they are, how to create them, how to version and update them, and a hands-on project deploying an unlocked package to a scratch org.
Everything you need to know about Scratch Orgs — what they are, creating them from org shapes, working with unlocked packages, and integrating scratch orgs into your development workflow.
A comprehensive guide to the Salesforce CLI — what it is, deploying metadata, importing data, creating scratch orgs and sandboxes, essential commands, and the most useful plugins.
Advanced Apex testing — true unit tests without database access, the Apex Mocks library, mocking selectors, services, and domains, and a complete project testing an fflib application.
The Gang of Four design patterns applied to Salesforce Apex — Singleton, Builder, Factory, Abstract Factory, Prototype, Facade, Composite, Adapter, Bridge, Decorator, Flyweight, Proxy, Observer, Template Method, Strategy, Chain of Responsibility, Command, and more.
A practical guide to the Apex Common Library — installing fflib, implementing the selector layer, domain layer, and service layer with the enterprise patterns framework.
Applying the five SOLID principles to Salesforce Apex — Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion, with practical Salesforce examples.
Understanding and implementing separation of concerns in Apex — the service layer, domain layer, selector layer, and how to structure enterprise Apex code for maintainability and testability.
Mastering OOP in Apex — abstraction, encapsulation, inheritance, polymorphism, and composition. With practical Salesforce examples and a project using polymorphism for runtime behavior changes.
A comprehensive guide to every major Salesforce API — REST, SOAP, Bulk, Tooling, Metadata, UI, Streaming, Reports & Dashboards, and Models API. When to use each, how they work, and a hands-on project.
Building AI agents on Salesforce — setting up the Agentforce VS Code extension, configuring agents, creating custom Apex agent actions, and building an agent that uses Apex to make decisions.
Writing clean, maintainable Apex — why methods should be small and do one thing, naming conventions that communicate intent, when to comment, and using PMD for static analysis.
Getting started with Git and GitHub for Salesforce development — installing Git, setting up local and remote repos, essential commands, branching strategies, and best practices.
A practical guide to Salesforce governor limits — SOQL, DML, CPU timeout, and integration limits. What they are, why they exist, how to hit them, and proven patterns to avoid them.
Understanding how Salesforce processes a record save — the complete order of execution from initial validation through triggers, flows, assignment rules, and DML statements. With practical examples showing how the order affects your code.
A hands-on project building a scheduled batch process — creating a service class, batch class, scheduled class, and comprehensive test classes for a real-world data update scenario.
A comprehensive guide to asynchronous Apex — batch classes, scheduled classes, queueable classes, future methods, and platform events. When to use each, how to set them up, and best practices.
A hands-on SOAP integration project — importing WSDLs, testing with SOAP UI, building a service class, and writing comprehensive test classes with WebServiceMock.
Build a production-quality REST integration between Salesforce and GitHub — from Named Credentials and Postman testing to wrapper classes, a service layer, and a complete test class with HttpCalloutMock.
A complete guide to Salesforce integrations — REST, SOAP, Named Credentials, wrapper classes, JSON2Apex, HTTP callouts, WSDL-generated classes, and writing test classes with mock interfaces.
Boost Salesforce performance with the Platform Cache — org cache vs session cache, partition setup, Cache.Org and Cache.Session classes, the CacheBuilder interface, TTL strategies, eviction policies, and testing patterns.
Learn how to build invocable Apex actions for Flows — @InvocableMethod, @InvocableVariable, input/output wrapper classes, bulkification, supported data types, error handling, testing, and a complete hands-on project.
A complete walkthrough of building a field mapping application in Apex — service classes that read mapping configuration from Custom Metadata, a controller that coordinates the logic, a Visualforce page to run it, and full test coverage.
Using Salesforce platform features in Apex — static resources for files, custom metadata types for app configuration, custom settings for org/user preferences, and custom labels for multilingual support.
Writing effective Apex test classes — minimum requirements, test setup, assertions, data factories, integration vs unit tests, Test.startTest/stopTest, and building a comprehensive test suite.
Everything about Apex triggers — trigger context variables, trigger handlers, bulkification, the order of execution, and best practices for writing production-grade triggers.
Enforcing security in Apex code — with/without/inherited sharing, object and field-level security, SOQL injection prevention, Apex managed sharing, and building security-aware applications.
Master the art of debugging Apex — debug logs in the Developer Console and VS Code, System.debug, code chunking, the Log Panel for identifying bottlenecks, and a hands-on debugging project.
Understanding type casting in Apex — implicit and explicit casting, upcasting and downcasting sObjects, the instanceof operator, and practical patterns for working with generic types.
Understanding error handling in Apex — exception types, try-catch-finally blocks, creating and throwing custom exceptions, and building resilient Salesforce applications.
Everything you need to know about querying data in Salesforce — SOQL SELECT, WHERE, ORDER BY, LIMIT, IN clauses, SOSL FIND and RETURNING, query limits, indexing, the Query Plan tool, and using queries in Apex.
Master control flow in Apex — if/else statements, switch statements, for loops, enhanced for loops, while and do-while loops, and best practices for iterating over collections efficiently.
Your entry point into Salesforce development — what Apex is, setting up your IDE, classes, variables, data types, methods, constructors, operators, collections, access modifiers, and the static keyword.
An admin's guide to Salesforce Data Cloud and Agentforce — setting up data streams, data models, identity resolution, Prompt Builder, and deploying AI agents.
Understanding Salesforce managed packages, the AppExchange marketplace, and how to evaluate, install, and manage third-party packages in your org.
How to set up Briefcase Builder for offline access and configure the Salesforce Mobile App for your users — installation, setup, and offline features.
Every tool Salesforce provides for bulk data operations — Mass Delete, Mass Transfer, team reassignments, address updates, the Data Wizard, and the Data Loader.
How to stay on top of Salesforce's three annual releases — release updates in Setup, release notes, sandbox preview, and preparing your org.
How to set up matching rules and duplicate rules in Salesforce to keep your data clean and prevent duplicate records.
How to set up the Translation Workbench and Experience Cloud site translations in Salesforce for multilingual orgs.
A deep dive into Salesforce org security — session settings, password policies, event monitoring, transaction security, platform encryption, field audit trail, and more.
How to set up SSO, two-factor authentication, Okta integration, and Experience Cloud authentication in Salesforce.
A complete guide to Salesforce OmniStudio — FlexCards, OmniScripts, DataRaptors (Data Mappers), Integration Procedures, and the Business Rules Engine.
How to move your customizations from sandbox to production — change sets, DevOps Center, scratch orgs, unlocked packages, and the Salesforce CLI.
Understanding Salesforce's legacy automation tools — Workflow Rules and Process Builder — what they are, how they work, why they're being retired, and how to migrate to Flows.
The definitive guide to Salesforce Flows — flow types, elements, resources, record-triggered flows, screen flows, scheduled flows, auto-launched flows, login flows, sub-flows, debugging, best practices, and hands-on projects.
A complete guide to email in Salesforce — deliverability settings, email templates, sending limits, list emails, mass emails, Flow emails, the EmailMessage object, and when to use external tools instead.
Everything you need to know about Salesforce Experience Cloud — creating sites, Aura vs LWR templates, user management, builder navigation, themes, authentication, security, CMS, gamification, and deployment.
A comprehensive guide to Salesforce Service Cloud — Cases, assignment and escalation rules, Email-to-Case, Web-to-Case, Case Teams, Entitlements, Omni-Channel, Knowledge, Quick Text, Surveys, Field Service, and more.
A comprehensive guide to Salesforce Sales Cloud — Campaigns, Leads, Opportunities, Products, Pricebooks, Quotes, Orders, Contracts, Forecasting, Territory Management, CPQ, and more.
How to set up and use Salesforce Chatter for team collaboration — feeds on records, Chatter groups, direct messaging, file sharing, and keeping your team connected within the CRM.
Understanding Salesforce's core relationship objects — Accounts, Contacts, Account hierarchies, Account Teams, Account Contact Relationships, Contact Roles, and the Account Relationship object.
A complete guide to Salesforce reporting — creating reports, custom report types, report folders, scheduling, exporting, dashboards, dashboard folders, and the power of one formula.
How to use Salesforce Topics to organize and categorize records, enabling users to discover related content and collaborate more effectively across the org.
How to build approval processes in Salesforce — from simple single-step approvals to complex multi-step workflows with parallel approvers, escalation, and automated actions.
How to set up Salesforce Paths to guide users through business processes with visual step-by-step indicators, key fields, and guidance for success at every stage.
Everything you need to know about Salesforce list views — creating them, granting user access, adding list view buttons, understanding limitations, and managing list view sprawl in your org.
How to distribute administrative responsibilities without granting full System Administrator access — setting up delegated administration for user management, custom object administration, and more.
Master Salesforce record access including OWD settings, role hierarchies, public groups, queues, sharing rules, sharing sets, restriction rules, and more. Learn the complete record access pyramid with hands-on examples and a practical project.
A comprehensive guide to Salesforce's permission model — profiles, permission sets, permission set groups, object and field permissions, system permissions, Apex class access, custom permissions, and when to use each.
How to create and configure Lightning apps and custom tabs in Salesforce — organizing your org's navigation into purpose-built experiences for different teams and use cases.
A complete guide to the Lightning App Builder — how to create record pages, use standard and custom components, set up conditional visibility, leverage dynamic forms and dynamic actions, and activate pages for your users.
How to use formulas to compute values, validation rules to enforce data quality, lookup filters to restrict related record selection, and custom labels for reusable text — the declarative logic layer of Salesforce.
A practical guide to quick actions, custom buttons, and custom links in Salesforce — how to create them, add them to page layouts, and understand the difference between object-specific and global quick actions.
How to control what users see on a record page using page layouts, how to create record types for different business processes, and how to map them together for a tailored user experience.
A deep dive into the Salesforce data model — standard vs custom objects, field types, relationships, Big Objects, global value sets, schema builder, field history tracking, and hands-on projects.
A complete guide to managing users in Salesforce — creating users, assigning licenses, resetting passwords, verifying logins, proxy login, and understanding how license types shape user access.
Everything you need to know to get started as a Salesforce Administrator — navigating the UI, understanding sandboxes, configuring company information, languages, storage, branding, and business hours.
A comprehensive guide to understanding Salesforce products, licenses, org editions, and staffing — everything you need to make an informed decision before investing in the platform.