Overview
Developer Fundamentals is the foundation section of the Platform Developer I exam. It covers four ideas: how the multi-tenant architecture and the Model-View-Controller (MVC) pattern shape everything you build, when a declarative feature such as a formula field or roll-up summary beats Apex, how to design objects, fields, relationships and external IDs, and where Agentforce for Developers fits into a coding workflow.
The section exists because most bad Salesforce code is code that never needed to be written, or code written against a poorly designed data model. Choosing master-detail over lookup decides whether you get roll-up summaries, cascade delete and inherited sharing for free. Understanding that governor limits come from shared infrastructure explains every bulkification rule in Process Automation and Logic, and the data model you pick here is the schema your SOQL, triggers and Lightning components rely on in later sections.
How it's tested
Questions here are mostly short scenarios that ask for the most appropriate or most efficient solution. Many list several technically working options, so the skill is ranking them: declarative before programmatic, the relationship type whose built-in behavior matches the requirement, and the field type that avoids extra maintenance. A few are straight concept checks on MVC or Agentforce for Developers.
-
Declarative or code
A business requirement is described and you pick between a formula field, roll-up summary, flow or Apex. The answer is the simplest tool that fully meets the requirement within platform limits.
-
Pick the relationship
A requirement mentions deletion behavior, ownership, sharing or aggregation, and you choose lookup, master-detail, a junction object or an external ID to satisfy it.
-
Name the layer or tool
You map a component to its MVC layer, or judge whether a task suits Agentforce for Developers and what review it still needs.
A scenario says each Expense must belong to one Report, expenses should disappear when the report is deleted, and the report must show the total spent. Ownership plus cascade delete points to master-detail, and master-detail unlocks a SUM roll-up summary on the report with no code. A lookup with an Apex trigger would also work, but it adds code, tests and limit exposure for something the platform provides declaratively.
Objectives 4
Official objectives from the Salesforce outline, in outline order.
1.1 Understand multi-tenant concepts and design frameworks, such as MVC architecture and Lightning Component Framework.Why shared infrastructure creates limits, and how MVC maps to Salesforce.
- What it means
- Every org runs on shared servers and a shared database, separated by org ID and metadata, so the platform enforces per-transaction governor limits to stop one tenant from starving others. MVC separates data (model), presentation (view) and logic (controller), and the Lightning Component Framework is the client-side framework that Aura components and Lightning Web Components run in.
- What to understand
- On Salesforce the model is sObjects and fields, the view is Visualforce markup or Lightning component HTML, and the controller is Apex or component JavaScript. Multi-tenancy is the reason code must be bulkified and limit-aware, not a background fact.
- How it shows up
- A question names a piece of a solution, such as a custom object, a Visualforce page or an Apex extension, and asks which MVC layer it belongs to, or asks why governor limits exist.
- Common confusion
- Candidates label a standard controller as the model because it reads data; it is a controller that exposes the model to the view.
1.2 Given a scenario, identify common use cases and best practices for declarative versus programmatic customizations, including governor limits, formula fields, and roll-up summaries.Choosing clicks or code, and knowing what formulas and roll-ups can do.
- What it means
- Salesforce recommends the declarative option when it meets the requirement, because it needs no test classes and is maintainable by admins. Formula fields calculate a value at read time from the same record or parent records; roll-up summary fields aggregate child records (COUNT, SUM, MIN, MAX) on the master of a master-detail relationship.
- What to understand
- Know the edges: a formula cannot aggregate child records, and a standard roll-up summary needs master-detail (or a supported standard relationship such as Account to Opportunity). Code becomes the right answer when logic needs complex branching, callouts, cross-object work beyond declarative limits, or a lookup-based aggregate that declarative tools cannot provide.
- How it shows up
- A scenario describes a calculated or aggregated value and offers a formula, a roll-up summary, a flow and a trigger; the requirement's relationship type and timing decide which is valid and simplest.
- Common confusion
- Formula fields are not stored, so they cannot fire triggers or flows when their computed value changes, and candidates who forget this design automation around them.
1.3 Given a scenario, determine, create, and access the appropriate data model including objects, fields, relationships, and external IDs.Objects, field types, relationship types and external IDs for integration.
- What it means
- Designing the schema means choosing standard or custom objects, field types, and relationships: lookup (loosely coupled, optional by default), master-detail (tightly coupled, required parent, cascade delete, inherited sharing and ownership), many-to-many through a junction object with two master-detail fields, and the hierarchical relationship on User. An external ID field stores a key from another system and is indexed for matching.
- What to understand
- Know that a detail record has no owner of its own and inherits sharing from the master, that an object can have at most two master-detail relationships, and that upsert with an external ID inserts or updates records without first querying Salesforce IDs. Access relationships in Apex with dot notation (child to parent) and subqueries on the child relationship name (parent to children, ending in __r for custom relationships).
- How it shows up
- Requirements about cascade delete, sharing, roll-ups, many-to-many links or loading data keyed by an ERP number point to a specific relationship or to an external ID with upsert.
- Common confusion
- Candidates choose a lookup for a child that must not exist without its parent; required behavior plus cascade delete and inherited security is master-detail.
1.4 Understand use cases and limitations of using Agentforce for Developers.What the AI coding assistant is good for, and what it does not replace.
- What it means
- Agentforce for Developers is Salesforce's AI-assisted development tool in the Salesforce VS Code extensions and Code Builder. It offers inline code completion and a chat-based Dev Assistant that can generate or explain Apex and Lightning Web Component code and draft test classes from natural-language prompts.
- What to understand
- Treat its output as a draft: it can be incomplete, inefficient or wrong, it does not know your full business requirements, and generated code still needs human review, real test assertions, security checks and a normal deployment. It speeds up writing code; it does not remove governor limits, coverage requirements or the declarative-first decision.
- How it shows up
- A scenario asks how a developer should use generated code or tests, and the correct option includes reviewing and validating the output rather than deploying it directly.
- Common confusion
- Candidates assume AI-generated tests guarantee meaningful coverage; tests that execute lines without asserting outcomes still pass while proving nothing.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Multi-tenancy
Many customer orgs share the same application servers and database, and each org's data and customizations are separated by org ID and metadata rather than separate infrastructure.
- Remember
- Governor limits exist because resources are shared, so every design decision on the exam is judged partly on how it consumes those limits.
- Tested as
- Explains the 'why' behind bulkification questions and appears directly in concept questions about the platform.
- Trap
- Treating limits as arbitrary rules to memorize instead of reasoning from shared resources, which makes new scenarios harder to judge.
-
Model-View-Controller (MVC)
The model is the data (sObjects and fields), the view is what users see (Visualforce markup, component HTML), and the controller is the logic connecting them (Apex controllers, extensions, component JavaScript).
- Remember
- Standard controllers, custom controllers and controller extensions are all in the controller layer, even when they mostly read data.
- Tested as
- Classification questions ask which layer a given component belongs to.
- Trap
- Calling a custom object or a standard controller the view because it appears on a page.
-
Lightning Component Framework
The client-side UI framework that runs Aura components and Lightning Web Components, using a component-based, event-driven model that renders in the browser.
- Remember
- Lightning Web Components are built on web standards and are the recommended model for new development; Aura and LWC can coexist on one page.
- Tested as
- Ties Developer Fundamentals to User Interface questions on component choice.
- Trap
- Assuming Lightning components render on the server like Visualforce pages, which drives wrong answers about performance and data access.
-
Formula field
A read-only field whose value is calculated from other fields on the same record or on parent records each time the record is read.
- Remember
- Formulas are not stored, cannot reference child records, and changes to their computed value do not fire triggers or record-triggered flows.
- Tested as
- Common correct answer for display-only calculations such as days open or a parent's region shown on the child.
- Trap
- Picking a formula to total child records, which needs a roll-up summary or code.
-
Roll-up summary field
A field on the master record that calculates COUNT, SUM, MIN or MAX across related detail records, optionally filtered.
- Remember
- Available on the master side of master-detail (and a few standard relationships such as Account to Opportunity), not on ordinary custom lookups.
- Tested as
- The default declarative answer whenever a parent needs an aggregate of its children.
- Trap
- Choosing a roll-up summary on a lookup relationship, which the platform does not offer; that case needs a flow or Apex.
-
Master-detail relationship
A tightly coupled parent-child relationship where the parent field is required, deleting the master deletes the details, and details inherit owner and sharing from the master.
- Remember
- An object can have up to two master-detail relationships, and it is the prerequisite for standard roll-up summaries.
- Tested as
- The answer when a scenario requires ownership by the parent, cascade delete, or roll-ups.
- Trap
- Forgetting that detail records lose their own owner field, which breaks requirements that each child be owned by a different user.
-
Lookup relationship
A loosely coupled relationship where the parent is optional by default and child records keep their own owner and sharing.
- Remember
- Deleting a lookup parent either clears the field or is blocked, depending on the field setting; cascade delete is not available on custom lookups by default.
- Tested as
- Correct when the child must exist independently or be owned and shared separately.
- Trap
- Choosing lookup and then needing roll-ups or cascade delete that only master-detail provides declaratively.
-
Junction object
A custom object with two master-detail relationships that links two other objects to model a many-to-many relationship.
- Remember
- The first master-detail field created becomes the primary relationship, which controls the junction record's look and feel and ownership.
- Tested as
- Appears when a scenario says one record of A relates to many of B and vice versa, such as candidates and job postings.
- Trap
- Modeling many-to-many with a multi-select picklist or two lookups on one of the objects.
-
External ID
A custom text, number, email or auto-number field marked as a unique identifier from an external system, indexed for search and matching.
- Remember
- Upsert with an external ID inserts or updates records, and can set relationships by the parent's external ID, without querying Salesforce IDs first.
- Tested as
- The answer to integration and data-load scenarios that key records by an ERP or legacy number.
- Trap
- Using a plain text field and a SOQL lookup per record, which wastes queries and hits limits in bulk loads.
-
Declarative-first principle
When a declarative feature fully meets a requirement, prefer it over Apex because it needs no test classes and is easier for admins to maintain.
- Remember
- Code is justified for complex logic, callouts, heavy processing, or requirements no declarative tool supports.
- Tested as
- Underlies most 'most efficient' or 'best practice' questions in this section.
- Trap
- Reading 'without code' as optional; if a declarative answer meets every stated requirement, it beats Apex.
-
Agentforce for Developers
An AI coding assistant in the Salesforce VS Code extensions and Code Builder that provides inline completion and a chat Dev Assistant for generating and explaining Apex, LWC and test code.
- Remember
- Generated code is a starting point that a developer must review, test with real assertions and deploy normally.
- Tested as
- Tested on appropriate use cases and on its limitations.
- Trap
- Treating generated code or tests as production-ready without review, security checks or meaningful assertions.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Lookup vs. master-detail vs. junction object
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Lookup | Optional, loosely coupled link between two objects | Child keeps its own owner and sharing; no cascade delete by default | Expecting a standard roll-up summary on a custom lookup |
| Master-detail | Required, tightly coupled parent-child link | Cascade delete, inherited owner and sharing, enables roll-up summaries | Using it when children must have their own owners |
| Junction object | Object with two master-detail fields linking two objects | Models many-to-many; primary master controls ownership and look | Modeling many-to-many with two lookups on one object |
Formula field vs. roll-up summary vs. Apex trigger
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Formula field | Calculated at read time from the record or its parents | Cannot see child records; not stored, so it fires no automation | Using it to total child amounts |
| Roll-up summary | Stored aggregate of detail records on the master | COUNT, SUM, MIN, MAX on master-detail without code | Expecting it on a custom lookup relationship |
| Apex trigger | Code that runs before or after DML on a record | Handles logic declarative tools cannot, at the cost of tests and limits | Writing a trigger for a roll-up the platform already provides |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Code first
- What candidates pick
- An Apex trigger or class for a requirement a formula, roll-up summary or flow can meet.
- Why it looks right
- It is fully flexible and feels like the developer answer on a developer exam.
- Why it's wrong
- Salesforce best practice is declarative first; code adds test, maintenance and governor limit cost with no benefit when clicks satisfy the requirement.
Clue to watch for Phrases such as 'most efficient', 'least maintenance' or 'without writing code', and a requirement simple enough for a standard feature.
-
Roll-up on a lookup
- What candidates pick
- A roll-up summary field on a parent connected by a custom lookup.
- Why it looks right
- Roll-up summaries are the obvious tool for totals.
- Why it's wrong
- Standard roll-up summaries require master-detail (or specific standard relationships), so on a custom lookup they are unavailable without changing the relationship or using a flow or Apex.
Clue to watch for The scenario states the relationship is a lookup and that children must exist without the parent.
-
Formula reaching down
- What candidates pick
- A formula field on the parent that sums child amounts.
- Why it looks right
- Formulas can reference related records, so it seems they can reach any related data.
- Why it's wrong
- Cross-object formulas only go up to parent records; they cannot reference or aggregate child records.
Clue to watch for The value needed comes from many related child records, not one parent.
-
Owner on the detail
- What candidates pick
- Master-detail for a child whose records must be owned and shared by different users.
- Why it looks right
- Master-detail delivers roll-ups and cascade delete that the scenario also mentions.
- Why it's wrong
- Detail records have no owner field; their access is controlled by the master, so per-child ownership is impossible.
Clue to watch for Any requirement that child records have their own owner or separate sharing.
-
Query then update
- What candidates pick
- Querying each incoming record's Salesforce ID by an ERP number before updating it.
- Why it looks right
- It mirrors how many developers think about matching records.
- Why it's wrong
- An external ID with upsert matches, inserts or updates in one DML operation and avoids per-record queries that break in bulk.
Clue to watch for Data arrives keyed by an external system's identifier, and both new and existing records are expected.
-
AI output as final
- What candidates pick
- Deploying code or tests generated by Agentforce for Developers as soon as they compile.
- Why it looks right
- The tool is official Salesforce tooling, so its output feels trustworthy.
- Why it's wrong
- Generated code can be wrong or inefficient and generated tests may lack assertions; the developer remains responsible for review, security and real verification.
Clue to watch for Answer options that differ only in whether the developer reviews and validates the generated output.
Answer framework
For any Developer Fundamentals scenario, use these steps to find the solution Salesforce expects.
- List every stated requirement, including deletion behavior, ownership, sharing, aggregation and whether code is allowed.
- Check whether a standard declarative feature such as a formula field, roll-up summary, validation rule or flow meets all of them.
- Pick the relationship type whose built-in behavior matches: master-detail for required parents, cascade delete and roll-ups; lookup for independent records; a junction object for many-to-many.
- Use an external ID with upsert whenever records arrive keyed by another system's identifier.
- Choose Apex only for what remains, such as callouts or complex branching, and treat any AI-generated code as a draft that still needs review and tests.
Practice question
Want more like this? The Salesforce PD1 practice test has questions for every domain.
Checklist
0 of 11
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Start with the data model, because every other section assumes it. Build a small schema in a free Developer Edition org: one master-detail pair with a roll-up summary, one lookup, a junction object, and an external ID field. Delete a master and watch the details go; try to add a roll-up on the lookup and see that the option is missing. Ten minutes of this is worth more than reading the comparison table twice.
Next, work through declarative-versus-code decisions. For each requirement you practice, write down the simplest tool that meets it and the one requirement that would force code. Formula limits (parents only, not stored) and roll-up prerequisites are the most commonly underestimated details.
Then cover the conceptual pieces: why multi-tenancy creates governor limits, where each component sits in MVC, and the Lightning Component Framework at a high level. Finish with Agentforce for Developers by trying it in VS Code if you can, paying attention to where its suggestions are wrong.
Afterwards, move to Process Automation and Logic, where the limits and relationships from this section turn into SOQL, triggers and bulkification, and test yourself with scenario questions that ask for the most efficient solution.
FAQ
How much of the Platform Developer I exam is Developer Fundamentals?
Developer Fundamentals is 27% of the exam, the second-largest section after Process Automation and Logic at 28%. Applied to the 60 scored questions, that suggests roughly 16 questions as a planning estimate.
Do I need to know declarative tools for a developer exam?
Yes. Many questions ask for the most efficient or maintainable solution, and the expected answer is often a formula field, roll-up summary or flow rather than Apex. You need to know their limits to recognize when code is truly required.
What is the difference between lookup and master-detail on the exam?
Master-detail makes the parent required, cascades deletes, makes the detail inherit owner and sharing, and enables roll-up summaries. Lookup keeps records independent with their own owners. Scenarios signal the right one through deletion, ownership and aggregation requirements.
Why do governor limits exist?
Salesforce is multi-tenant, so many orgs share the same servers and database. Per-transaction limits on queries, DML, CPU time and heap stop one org's code from degrading performance for others, which is why bulkified code matters.
What should I know about Agentforce for Developers?
Know that it provides AI code completion and a chat assistant in VS Code and Code Builder that can generate and explain Apex, Lightning Web Components and tests. Also know its limits: output must be reviewed, tested with real assertions and deployed through normal processes.
When should I use an external ID?
Use one when records come from another system with its own identifier. Marking the field as an external ID indexes it and lets upsert insert or update records and set relationships by that key, without querying Salesforce IDs first.
How does this section connect to the rest of the exam?
The data model you choose here is what your SOQL and triggers in Process Automation and Logic query, and the MVC and component framework concepts reappear in User Interface. Recognizing when code is unnecessary also saves time on every later scenario.
Other CRM & Business Applications certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 1 knowledge
You have worked through declarative-first decisions, relationship types, external IDs and Agentforce for Developers. Check whether you can pick the most efficient solution in timed scenario questions.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the Salesforce PD1 AI tutor Get any concept explained your way