Salesforce Platform App Builder

Every app needs a clear answer to who may see and change its data. You apply object and field permissions, organization-wide defaults, roles and sharing rules, and test the result from each user’s side.

• Permission sets and profiles for app access
• Object and field permissions
• Organization-wide defaults
• Roles and the role hierarchy
• Sharing rules and manual sharing
• Testing access as another user

You build An access design for one app, tested from three user perspectives.

An app is judged by what it shows managers. You build reports from standard and custom report types, group and filter them, and place charts on dashboards that answer real questions.

• Report types and custom report types
• Filters, groupings and summaries
• Matrix and joined reports
• Dashboards and chart choices
• Report and dashboard folders and sharing
• Putting reports on record pages

You build A report set and dashboard for the app’s main business question.

The data model is the foundation, and it is hard to change later. You choose between standard and custom objects, pick relationship types, and select the field type that fits each piece of data.

• Standard objects or custom objects
• Lookup, master-detail and many-to-many relationships
• Choosing field data types
• Picklists, record types and dependent fields
• Schema Builder and object relationships
• Planning a model from a business scenario
• Limits on fields and relationships

You build A data model for a business scenario, with each relationship and field type justified.

Data arrives from spreadsheets and other systems, and leaves again for audits and backups. You choose the right import tool, use external IDs to relate records, and export safely.

• Data Import Wizard and Data Loader compared
• Preparing a file for import
• External IDs and upsert
• Importing related records in order
• Avoiding duplicates on import
• Exporting data and scheduling exports

You build A tested import of related records from spreadsheets, with duplicates handled.

Calculated fields keep data consistent without code. You write formulas for text, numbers, dates and logic, build roll-up summaries across master-detail relationships, and avoid the limits that make formulas break.

• Formula field syntax and functions
• Text, number and date formulas
• Logical formulas and cross-object references
• Roll-up summary field types and filters
• Formula size and compile limits
• Debugging a formula that returns the wrong answer

You build A set of formula and roll-up fields that calculate a score and a total for an app.

Bad data costs more to fix than to prevent. You write validation rules that catch errors at save, give users clear messages, and let administrators bypass them safely during loads.

• How validation rules run on save
• Writing rule formulas
• Error messages and placement
• Rules across related records
• Bypassing rules for data loads safely
• Testing rules with edge cases

You build A validation rule set with clear messages and a safe bypass.

Flow is the main automation tool of the platform. You build record-triggered, screen, scheduled and autolaunched flows, work with variables, loops and decisions, and choose the right flow type for each process.

• Flow types and when each fits
• Record-triggered flows before and after save
• Screen flows for guided input
• Scheduled and autolaunched flows
• Variables, loops and decisions
• Fault paths and error messages

You build Three flows of different types that automate one business process.

Some processes need a person to decide, and every flow eventually misbehaves. You build approvals, use debug and run history to troubleshoot flows, and see where Agentforce can take over steps from a flow.

• Approval processes and flow approvals
• Approvers, queues and delegation
• Debugging a flow in the builder
• Reading flow run history and error emails
• Testing flows before activation
• Where Agentforce fits next to automation

You build An approval flow with a documented debugging of one fault.

People work through what they see on a record. You customize actions, buttons and links, set up page layouts and compact layouts per role, and keep screens short enough to be used.

• Quick actions and global actions
• Buttons, links and custom URLs
• Page layouts and related lists
• Compact layouts and highlights
• Layouts by record type and profile
• Making the record page easier to use

You build Role-specific layouts and actions for one object.

Lightning App Builder lets you shape pages without code. You build record, app and home pages, use dynamic forms and visibility rules, add components, and check how the app looks on mobile.

• Lightning App Builder page types
• Dynamic forms and component visibility
• Standard components on a page
• Adding custom Lightning components
• Navigation items and apps
• Designing and testing for mobile

You build A Lightning app with record pages, visibility rules and mobile checks.

An app must travel from build to production without breaking anything. You choose a sandbox type, move changes with change sets or packages, and plan a deployment with testing and rollback in mind.

• Sandbox types and refreshes
• Building and validating change sets
• Packages and what they carry
• Choosing a deployment approach
• Pre- and post-deployment steps
• Testing in a sandbox before release

You build A deployment plan that moves an app from sandbox to production.

Build one complete app from a business story: data model, access, automation, interface, reports and deployment. You choose each tool on purpose and explain where you stopped using clicks.

• Turning a business story into requirements
• Building the model and the automation
• Shaping the interface and reports
• Securing and deploying the app
• Reviewing the build against the story

You build A complete no-code app with data model, flows, interface, reports and a deployment plan.