ExamFinch.com My Study

Study guide

1.2 Blueprint Weights & Study Strategy

Practice this exam

Salesforce Certified Platform Developer I Exam

Track your progress as you read

Finished sections get a check mark.

1 Introduction & Exam Overview

1.1 Current Exam Facts 1.2 Blueprint Weights & Study Strategy

2 Platform Fundamentals

2.1 Multi-Tenant Architecture & Shared Resources 2.2 MVC Mapping on the Lightning Platform 2.3 Declarative vs Programmatic Decisions 2.4 Agentforce for Developers: Use Cases & Limitations

3 Data Modeling & Schema

3.1 Objects, Fields & Schema Design 3.2 Relationship Types & Implications 3.3 Schema Design Impact on Apex 3.4 Data Import & Export for Development

4 Platform Data Features

4.1 Formula Fields & Roll-Up Summaries 4.2 Core CRM Objects & Standard Schema 4.3 AppExchange Extensions & Platform Boundaries

5 Declarative Process Automation

5.1 Record-Triggered Flows & Declarative Automation 5.2 Approval Processes & Business Rules 5.3 When to Use Apex vs Declarative Tools

6 Apex Language Basics

6.1 Variables, Constants & Apex Data Types 6.2 Lists, Sets & Maps 6.3 Control Flow & Exception Handling 6.4 Classes, Interfaces & OOP Patterns

7 SOQL, SOSL & DML

7.1 SOQL Query Fundamentals 7.2 SOSL Search Fundamentals 7.3 DML Operations & Bulkification 7.4 Governor Limits & Transaction Boundaries

8 Apex Triggers & Order of Execution

8.1 Trigger Structure & Context Variables 8.2 Bulk Trigger Patterns & Best Practices 8.3 Save Order of Execution 8.4 Recursion, Cascading & Transaction Control

9 Asynchronous Apex

9.1 @future Methods 9.2 Queueable Apex 9.3 Batch Apex 9.4 Schedulable Apex & Job Orchestration

10 Security, Events & Schema Access

10.1 Sharing, FLS, CRUD & Injection Prevention 10.2 Platform Events Publish & Subscribe 10.3 Programmatic Schema Access (Describe)

11 Visualforce

11.1 Visualforce Pages & Markup 11.2 Standard, Custom Controllers & Extensions 11.3 Visualforce in Lightning Experience

12 Lightning Components

12.1 Lightning Component Framework Benefits 12.2 Aura Component Structure & Resources 12.3 Lightning Web Components Fundamentals 12.4 LWC Data Access: Wire, Imperative & Events

13 UI Composition & Apex Integration Patterns

13.1 Composing UI in Lightning Apps 13.2 UI Security, Performance & Accessibility Patterns 13.3 Apex Actions for Flow, LWC, and Agentforce

14 Apex Testing

14.1 Testing Framework & Coverage Requirements 14.2 Writing Unit Tests for Triggers & Classes 14.3 Test Data Strategies & Isolation 14.4 Executing Tests & Execute Anonymous Differences

15 Debugging & Developer Tools

15.1 Debug Logs & Monitoring 15.2 Developer Console, CLI, VS Code & Workbench 15.3 Sandboxes, Scratch Orgs & Environment Strategy

16 Deployment & Release

16.1 Change Sets & Metadata Deployment 16.2 Unlocked Packages, Metadata API & Salesforce DX 16.3 Release Readiness & Credential Maintenance

1.2 Blueprint Weights & Study Strategy

Key Takeaways Explain This Topic AI

Current Trailmix domain weights are Developer Fundamentals 27%, Process Automation and Logic 28%, User Interface 25%, and Testing, Debugging, and Deployment 20%

Process Automation and Logic is the single highest-weight domain—prioritize Flow vs Apex decisions, bulk Apex, triggers, and governors

Pair Trailhead trailmix modules with hands-on work in a free Developer Edition or scratch org; reading alone is not enough for PDI

Use a phased plan: foundations → automation/Apex depth → UI → testing/deploy, then timed practice with the free ExamFinch bank

For 60 questions in 105 minutes, aim for roughly 1.5–1.75 minutes per item, flag long scenarios, and protect time for multi-select items

Last updated: August 2026

1.2 Blueprint Weights & Study Strategy

Quick Answer: Study against the four-domain Trailmix map— Developer Fundamentals 27% , Process Automation and Logic 28% , User Interface 25% , Testing, Debugging, and Deployment 20% . Spend the most deep-work time on Process Automation and Logic , build everything hands-on in a Developer Edition or scratch org , complete the official Trailhead trailmix , then harden with timed practice (including the free ExamFinch question bank) under a 105-minute / 60-question clock.

Section 1.1 fixed logistics. This section turns the blueprint weights into a study calendar so you do not over-invest in low-yield trivia or under-invest in bulk Apex and testing.

Official Current Domain Weights (Trailmix Map)

Domain Weight What it stresses on the exam

Developer Fundamentals 27% Multi-tenant mindset, MVC mapping on the platform, declarative vs programmatic choices, data model/schema impact, external IDs, CRM objects, formulas/roll-ups, AppExchange/platform boundaries, and the use cases and limitations of Agentforce for Developers

Process Automation and Logic 28% Flow and declarative automation, Apex language/collections, SOQL/SOSL/DML, bulkification, governor limits, triggers & order of execution, async Apex, security in code, platform events

User Interface 25% Visualforce pages/controllers, Lightning Component Framework benefits, Aura resources, Lightning Web Components, data wire/imperative patterns, composing Lightning apps, UI and data-access security, and Apex that works with page components including Flow and Agentforce actions

Testing, Debugging, and Deployment 20% Apex test framework & coverage rules, unit tests for triggers/classes, test data isolation, debug logs, Developer Console/CLI/VS Code/Workbench, sandboxes/scratch orgs, change sets, packages/DX, release readiness

Why this map matters: Older six-domain outlines reallocated Logic, UI, and Testing into different slices. If a blog still says “Logic and Process Automation 46%” as a single mega-domain from a legacy PDF, treat that as historical . This guide’s later chapters still spend heavy page count on Apex because Process Automation and Logic at 28% plus fundamentals that feed automation remain the densest technical load—even when the official label is four domains.

Weight-based hour budgeting (example for ~120 study hours)

  • Domain Weight Suggested share of study hours Example hours
  • Developer Fundamentals 27% ~25–28% 30–34
  • Process Automation and Logic 28% ~30–35% (slight boost for code density) 36–42
  • User Interface 25% ~22–25% 26–30
  • Testing, Debugging, Deployment 20% ~18–22% (slight boost near exam week) 22–26

You may nudge Testing/Deploy upward in the final two weeks because coverage mistakes and deployment misconceptions are common fail modes even when candidates can write Apex in a playground.

  • What “Good Enough” Looks Like Per Domain
  • Developer Fundamentals (27%)

You should be able to:

  • Explain multi-tenant implications (shared resources, governor limits as fairness controls)
  • Map Model / View / Controller ideas onto objects, UI, and Apex/controllers
  • Choose Flow vs Apex vs formula vs roll-up for a stated requirement
  • Design lookup vs master-detail vs junction relationships and predict sharing/cascade effects

Name when work belongs on Lightning Platform vs off-platform (for example, Heroku-style compute) without overselling either

State the use cases and limitations of Agentforce for Developers —including the editions and regions where it is unavailable

Process Automation and Logic (28%) — highest weight

You should be able to:

  • Implement record-triggered Flow patterns and know approval-process roles
  • Write bulk-safe triggers with handler classes; avoid SOQL/DML inside loops
  • Use Lists, Sets, Maps intentionally (for example, Map for parent lookups)
  • Query with SOQL (including relationships) and know when SOSL is appropriate
  • Respect governor limits and transaction boundaries; reason about order of execution
  • Select @future , Queueable , Batch , or Schedulable for a scale/latency story
  • Apply CRUD/FLS/sharing and injection-safe dynamic SOQL habits
  • User Interface (25%)

You should be able to:

  • Build Visualforce pages with standard/custom controllers and extensions
  • State Lightning Component Framework benefits (client-side, event-driven composition)
  • Contrast Aura resource bundles with LWC standards-based components
  • Load data via wire and imperative Apex; fire/handle component events
  • Place components on App Builder record pages and respect UI security/performance basics

Expose Apex to declarative and AI surfaces with @InvocableMethod so a Flow or an Agentforce agent action can call it

Testing, Debugging, and Deployment (20%)

You should be able to:

  • Write isolated unit tests with assertions; understand minimum coverage for deployment
  • Create test data in-test (and know when @testSetup helps)
  • Read debug logs , set trace flags, and use Developer Console / Salesforce CLI / VS Code appropriately

Choose sandbox vs scratch org for a task; deploy with change sets , Metadata API , or unlocked packages / DX workflows at a conceptual level

  • Four-Phase Study Plan
  • Phase 1 — Foundations (about 20–25% of calendar)
  • Trailhead modules covering platform basics, data modeling, and security fundamentals

In a free Developer Edition org: create a custom app, objects, relationships, validation rules, formula fields, and a roll-up where master-detail allows it

  • Draw the MVC mapping of your sample app on paper once—this anchors Fundamentals questions
  • Phase 2 — Process Automation & Apex depth (largest phase)

Build the same business process twice when possible: once primarily in Flow , once with trigger + handler , and write notes on which is maintainable

Daily coding drills: collections, SOQL in loops (broken) → refactored bulk version, simple async job

Keep a personal governor limit cheat sheet; practice explaining limits in plain English (queries, DML statements, CPU, heap)

Walk order of execution with a whiteboard scenario (before-save flow vs before trigger vs after trigger vs assignment rules, etc.)

  • Phase 3 — User Interface
  • One Visualforce page with a standard controller extension that performs a constrained DML path
  • One LWC that displays related records via wire service and one imperative Apex action

Drop components onto a Lightning record page; verify visibility and performance basics (lazy loading mindset, avoid chatty Apex)

Phase 4 — Testing, debugging, deployment, and exam simulation

Raise a non-trivial class/trigger to solid test coverage with positive, negative, and bulk tests (200-record habits)

  • Break something on purpose, read the debug log , fix it
  • Deploy a change set between related environments (or simulate DX retrieve/deploy in a scratch org pipeline)
  • Run full timed practice sets: 60-ish questions in 105 minutes
  • Hands-On Environment Strategy
  • Environment Best use
  • Developer Edition Long-lived playground for UI experiments, sample data, and Trailhead integration

Scratch orgs (Salesforce DX) Disposable orgs for clean metadata experiments, package-oriented workflows, CI-like habits

Sandbox (if you have a production sponsor) Realistic profiles/permission sets—but never study with production data

Rule: Every major blueprint skill should leave an artifact in an org (Flow, trigger, LWC, test class, change set). If you only watch videos, Process Automation items will feel abstract under time pressure.

Official Trailmix + ExamFinch Practice

Trailhead trailmix for Platform Developer — follow the official module sequence that maps to the four domains; complete hands-on challenges, not just quizzes.

Release notes skimming — especially Apex, Flow, and Lightning changes in the last one or two releases.

Free ExamFinch practice bank for salesforce-developer — use it to expose weak subtopics (for example, async Apex vs testing isolation). Review every miss by rebuilding the scenario in your org when possible.

Spaced review — Anki-style flash or short daily drills on governors, order of execution, and coverage rules beat weekend cramming.

Time Management on Exam Day (60Q / 105m)

  • Tactic Why
  • First pass: answer or flag within ~2 minutes Protects against early time sinks on long scenarios

Multi-select: count required choices carefully Partial guessing without reading “select two/three” is a common self-own

  • Watch absolute clock at questions 20 / 40 / 60 105 minutes → rough checkpoints at 35 and 70 minutes
  • Do not hunt for unscored items You cannot identify them; all items cost time
  • Second pass: only flagged items Prefer finishing with a guess over leaving blanks if the UI allows review

Pacing formula: 105 ÷ 60 ≈ 1.75 minutes per scored question. If you expect up to five unscored items, plan closer to 1.5–1.6 minutes average so the last block is not a panic sprint.

Common Study Traps

Studying the stale 6-domain PDF weights while ignoring the four-domain Trailmix map.

Admin-only prep (page layouts and reports) without bulk Apex and tests.

Memorizing syntax without transaction reasoning (when does a governor blow up?).

Skipping UI because “I’m a backend dev”—UI is 25% .

Skipping deployment/testing because “I’ll learn that on the job”—it is 20% and full of sharp edges (coverage, test isolation, change sets vs packages).

Untimed practice only — knowledge without pacing still fails a 105-minute exam.

8-Week Sample Skeleton (Adjust to Your Hours)

  • Weeks Focus
  • 1–2 Fundamentals + data model labs; start Trailmix
  • 3–5 Process Automation & Logic deep work (Flow, Apex, triggers, async)
  • 6 User Interface (VF + LWC) labs
  • 7 Testing, debug logs, environments, deployment mechanics
  • 8 Timed mixed practice, weak-topic repair, light review of governors/OOE/coverage

Working full-time? Stretch to 12 weeks by keeping daily 45–60 minute coding blocks rather than only weekend marathons.

How the Rest of This Study Guide Is Organized

Chapters ahead follow the blueprint, not random blog order:

Fundamentals & data chapters (including 2.4 on Agentforce for Developers) → support the 27% Fundamentals domain

  • Declarative automation, Apex, SOQL/DML, triggers, async, security/events → carry the 28% Process domain
  • Visualforce, Lightning, UI composition, and Apex actions for Flow/Agentforce (13.3) → cover the 25% UI domain
  • Testing, debug tools, deployment → cover the 20% Testing/Debug/Deploy domain

Bottom line: Weight your calendar to 27 / 28 / 25 / 20 , overweight hands-on Process Automation and Logic , build in Developer Edition/scratch orgs , finish the Trailmix , then prove readiness with timed ExamFinch practice until 105 minutes feels routine.