Updated for Winter '26
App Builder Study Guide (Winter '26): Complete Platform App Builder Exam Prep
The Salesforce Platform App Builder certification validates your ability to design, build, and deploy custom applications using Salesforce's declarative tools. This study guide covers every exam section with the Flow Builder patterns, data model decisions, and deployment procedures you need to pass.
Written and reviewed by Krishna Mohan — ADM-201, PD1, PD2, App Builder & Consultant certified. Updated for Winter '26. Methodology · Contact
App Builder Exam at a Glance
60
Questions
105 min
Time Limit
63%
Passing Score
$200
Exam Fee
Retake fee: $100. No prerequisites required. App Builder is often taken after ADM-201 as the second admin-track certification.
App Builder Exam Sections and Weightage
Business Logic + Fundamentals + Data Modeling = 71% of the exam. Master these three first.
Flow Builder (record-triggered, screen, scheduled), approval processes, validation rules, formula fields, order of execution
Platform basics, MVC pattern, declarative vs programmatic, user management, org setup, sharing model overview
Custom objects, field types (formula, roll-up summary, lookup, master-detail), schema relationships, data quality, import/export tools
Lightning App Builder, page types (Home, Record, App), dynamic pages, component visibility rules, Lightning Experience navigation
Change sets (outbound/inbound), sandbox types (Developer, Partial Copy, Full), deployment best practices, managed vs unmanaged packages
What Each Section Actually Tests
Business Logic and Process Automation (28%)
Flow Builder is the dominant topic here. Record-triggered flows: before-save triggers update fields on the triggering record without DML (faster, more efficient); after-save triggers are needed when you must query or update related records after insert. Screen flows: collect user input through screens, use input components (text, picklist, lookup), and can launch from a button on a record page. Approval processes: entry criteria, initial submission actions, one or multiple approval steps, final approval/rejection actions. Validation rules: evaluate before triggers fire — return an error message when a specific formula is TRUE. Order of execution (simplified): system validation → before triggers → custom validation rules → after triggers → assignment rules → workflow rules → flows → process builder → escalation rules.
Salesforce Fundamentals (23%)
Platform basics, MVC architecture, and sharing model. Declarative vs programmatic: always prefer declarative (Flow, validation rules, formula fields) unless the requirement cannot be met declaratively — the exam rewards the least-code answer. Sharing model: org-wide defaults (OWD) control the baseline access; roles grant upward visibility; sharing rules open access horizontally; manual sharing allows one-off exceptions. User management: profiles control object access (CRUD) and app access; permission sets grant additional permissions without changing the profile; permission set groups bundle multiple permission sets.
Data Modeling and Management (20%)
Object relationships: master-detail (required parent, cascade delete, roll-up summary fields available), lookup (optional parent, no cascade delete, no roll-up), many-to-many via junction object (two master-detail relationships). Field types: formula fields are read-only calculated fields; roll-up summary fields summarise (COUNT, SUM, MIN, MAX) child records — only available on master-detail parent. Schema considerations: a lookup field can be converted to master-detail if no existing records violate the required parent rule. Import tools: Import Wizard (up to 50,000 records, standard + select custom objects, no CLI), Data Loader (bulk operations, all objects, command-line capable, schedule-able).
User Interface (17%)
Lightning App Builder: three page types — Home pages (org, app, or user default), Record pages (per object, per record type, per app), App pages (custom tabs). Dynamic pages: Component visibility rules hide/show components based on field values or user attributes — no custom code needed. App Manager: create Lightning apps with custom branding, utility bar, and navigation items. Compact layouts control the fields shown in the highlights panel on record pages and in mobile cards. Record types control page layout, picklist values, and business process assignment.
App Deployment (12%)
Change sets: outbound change sets (source org — add components), inbound change sets (target org — validate and deploy). Change sets cannot delete components; use metadata API or CLI for destructive changes. Sandbox types: Developer (5 MB data, 1/day refresh), Developer Pro (1 GB data), Partial Copy (5 GB data, sampled), Full (full copy of prod, 29-day refresh). Packages: unmanaged packages = full source, upgradeable only by customer; managed packages = locked code, upgradeable by publisher (AppExchange). Order of deployment: validate (dry run) → check for errors → deploy → activate flows, rules, permission sets.
Key Decision Frameworks for Exam Questions
Automation tool selection:
- Update a field when a record is saved, no user input → Before-save record-triggered Flow
- Create a related record or send email after insert → After-save record-triggered Flow
- Collect user input through a guided wizard → Screen Flow
- Multi-step approval with manager hierarchy → Approval Process
- Cannot be done declaratively → Apex (correct to acknowledge, but exam prefers declarative)
Relationship type selection:
- Child cannot exist without parent + need roll-up → Master-Detail
- Child can exist independently → Lookup
- Many-to-many relationship → Junction object with two master-detail relationships
4-Week App Builder Study Plan
Week 1 — Business Logic and Process Automation (28%): Flow Builder deep dive — record-triggered (before/after), screen flows, scheduled flows, approval processes, validation rules, and order of execution. Practice: build a record-triggered flow that creates a follow-up task on Opportunity close, and a screen flow for new case intake.
Week 2 — Fundamentals + Data Modeling (43%): Sharing model (OWD, roles, sharing rules), profiles vs permission sets, MVC, custom objects, field types (formula, roll-up summary, lookup, master-detail), schema design patterns, Import Wizard vs Data Loader. Practice: design a data model for a custom app (e.g., event management) with proper relationship types.
Week 3 — UI + Deployment (29%): Lightning App Builder (page types, dynamic components, component visibility), compact layouts, record types, App Manager. Change sets, sandbox types, package types, deployment order. Practice: create a custom Lightning app with a custom record page using dynamic components.
Week 4: Full timed mock exams (60 Q / 105 min). Score 73%+ consistently before booking (App Builder passing is 63% — aim 10 points above).
How to Approach App Builder Scenario Questions
- Automation questions: Always pick the least-code option that satisfies all stated requirements. If the scenario says “no code,” eliminate Apex answers. If the requirement can be done with a before-save flow, that is preferred over after-save (no DML, more efficient).
- Data model questions: Identify whether the child record can exist without the parent. If yes → lookup. If no → master-detail. If the question mentions “roll-up summary field,” the relationship must be master-detail on the parent object side.
- Deployment questions: Change sets are used to move metadata between related orgs (sandbox → production with the same organization). Unmanaged packages are for distributing customisations. Managed packages are for AppExchange listings. If the question asks about deleting components, change sets cannot do it — metadata API is required.
- UI questions: Component visibility rules in Lightning App Builder are the declarative answer for “show this component only when the account type is Customer.” Dynamic forms allow field-level visibility rules on record pages. If a component needs to appear on the home page only for users with a specific profile, that is a Home page variant assigned by profile.
Mock-Test Benchmark Before Booking
73%+ on 3 timed full mocks (60 Q / 105 min) before booking
App Builder has the lowest passing score (63%) of the three admin-track exams, but do not be overconfident — the Flow Builder questions involve detailed scenario analysis. The most common failure mode is weak performance on deployment questions (change sets, sandbox types) — do not neglect the 12% App Deployment section even though it is the smallest.
Top 10 Topics to Review the Day Before
- Before-save vs after-save record-triggered flow — when to use each and why
- Order of execution: validation rules fire before triggers; flows fire after DML
- Formula fields vs roll-up summary fields — read-only, when each is appropriate
- Master-detail vs lookup — required parent, cascade delete, roll-up eligibility
- OWD settings and their effect on record visibility (not field access)
- Lightning App Builder page types: Home, Record, App — scope of each
- Component visibility rules — what attributes you can filter on (field values, user attributes)
- Sandbox types: Developer (5 MB), Developer Pro (1 GB), Partial Copy (5 GB), Full (full copy)
- Change set limitations: cannot delete metadata, cannot move between unrelated orgs
- Import Wizard vs Data Loader — 50k record limit, object support, scheduling capability
What to Take After App Builder
Once you've passed App Builder, you can either deepen your admin track or specialise by cloud:
- Stay on the core admin path with Advanced Administrator if you enjoy complex security, governance, and auditing scenarios.
- Move into implementations with Sales Cloud Consultant, Service Cloud Consultant, or Experience Cloud Consultant depending on whether your org is sales, service, or portal focused.
Related Guides
Compare Certifications
Practice With Real Exam-Style Questions
Apply this study guide with free App Builder practice questions, exam weightage breakdown, and prep tips:
What Comes After This Certification?
After this certification, consider: Platform Developer II, Platform App Builder, or JavaScript Developer I.
Exam Section Difficulty Heatmap
Which sections are a gimme vs which ones trap confident candidates. Use this to prioritise your final-week revision.
| Exam Section | Difficulty | Study Tip |
|---|---|---|
| Data Modeling and Management | Moderate | OWD inheritance in Master-Detail relationships is frequently tested in scenarios. |
| User Interface | Moderate | Lightning App Builder vs Classic App Builder differences and component visibility rules. |
| Business Logic and Process Automation | Trap ⚠ | Declarative-first principle: if Flow can solve it, that is the exam answer even if Apex would also work. |
| Reports and Dashboards | Easy | Report types, joined reports, and dashboard filter limitations (equality-only) are the key sub-topics. |
| Deployment | Moderate | Change Sets vs Metadata API vs Packages — know which to recommend for each deployment scenario. |
| Mobile and Lightning | Hard | Salesforce Mobile App navigation is separate from Lightning App navigation — this distinction appears in several questions. |
Difficulty based on analysis of common candidate errors across each exam section.
Ready to Test Your Knowledge?
Try the Platform App Builder free practice exam — scored with full explanations.
Platform App Builder Free Practice Exam →