1.2 Blueprint Weights & Study Strategy

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 OpenExamPrep 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)

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)

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

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 + OpenExamPrep Practice

1. Trailhead trailmix for Platform Developer — follow the official module sequence that maps to the four domains; complete hands-on challenges, not just quizzes.
2. Release notes skimming — especially Apex, Flow, and Lightning changes in the last one or two releases.
3. Free OpenExamPrep 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.
4. 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)

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

1. Studying the stale 6-domain PDF weights while ignoring the four-domain Trailmix map.
2. Admin-only prep (page layouts and reports) without bulk Apex and tests.
3. Memorizing syntax without transaction reasoning (when does a governor blow up?).
4. Skipping UI because “I’m a backend dev”—UI is 25%.
5. 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).
6. Untimed practice only — knowledge without pacing still fails a 105-minute exam.

8-Week Sample Skeleton (Adjust to Your Hours)

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 OpenExamPrep practice until 105 minutes feels routine.