Updated for Winter '26
Salesforce JavaScript Developer I Exam Tips (Winter '26): How to Pass
The JavaScript Developer I exam tests your knowledge of JavaScript language fundamentals and Lightning Web Components. These tips focus on the asynchronous patterns, LWC lifecycle, and browser APIs that define the hardest questions on this exam.
Written and reviewed by Krishna Mohan — ADM-201, PD1, PD2, App Builder & Consultant certified. Updated for Winter '26. Methodology · Contact
Exam At a Glance
60
Questions
105 min
Time Limit
65%
Passing Score
$200
Exam Fee
Quick Answer: What JavaScript Developer I Tests
- JavaScript fundamentals — Variable scoping (var/let/const), closures, prototype chain, the event loop, promises, async/await, and error handling. The exam tests language behaviour, not just syntax.
- Lightning Web Components (LWC) — Component lifecycle hooks (@api, @track, @wire), event communication between parent and child, wire adapters vs. imperative Apex calls, and reactive properties.
- Browser and Node fundamentals — DOM manipulation, fetch API, modules (import/export), and Node.js basics (npm, module system). Testing concepts with Jest are also tested.
Highest-Weight Exam Sections
LWC + Fundamentals + Async = 68%. Master the event loop, promises, and LWC lifecycle before anything else.
Scenario Strategy: How to Approach JavaScript Developer I Questions
Questions present JavaScript code snippets and ask what the output is, or describe an LWC requirement and ask which decorator or pattern to use. Read code questions carefully — variable hoisting, closure scope, and promise resolution order are common traps.
- For async questions: understand the order of execution — synchronous code first, then microtasks (Promise.then), then macrotasks (setTimeout). This determines output order in code-reading questions.
- For LWC questions: @api exposes properties to parent components; @wire connects to Salesforce data; @track (legacy) makes complex objects reactive. Know when to use wire vs. imperative Apex calls — wire for read-only data that refreshes automatically, imperative for conditional/user-triggered data loads.
- For event questions: custom events use CustomEvent and dispatch upward. Child-to-parent: fire event from child, listen with on[eventname] in parent template. Parent-to-child: use @api property or method call. Know this direction — it is tested directly.
Mock-Test Benchmark Before Booking
75%+ on 3 timed full mocks before booking
Build at least 3–5 LWC components in a Salesforce scratch org or Developer Edition before booking. Candidates who only study theory without hands-on LWC experience consistently struggle with the implementation scenario questions that make up the bulk of the exam.
3 Concepts That Fail Most JavaScript Developer I Candidates
These are not the hardest topics — they are the ones where candidates are most confidently wrong. Learn the distinction early.
1. Promises vs Async/Await — Same Mechanism, Different Syntax
Promises and async/await both handle asynchronous operations — async/await is syntactic sugar over Promises. A function marked async always returns a Promise. await pauses execution until the Promise resolves. Candidates treat these as entirely different mechanisms and struggle with error handling: rejected Promises in async/await are caught with try/catch, not .catch(). Know both patterns and when the exam expects each.
2. var vs let vs const — Scope and Reassignment Rules
var is function-scoped and hoisted (available before its declaration line at runtime, with value undefined). let is block-scoped and not accessible before declaration (temporal dead zone). const is block-scoped and cannot be reassigned (but the object it references can be mutated). Candidates use var for all declarations — the exam expects let for mutable block-scoped variables and const for values that should not be reassigned.
3. Event Bubbling vs Capturing — Two Phases of DOM Event Propagation
Events propagate in two phases: Capturing (top-down, from document to target) then Bubbling (bottom-up, from target back to document). addEventListener defaults to Bubbling phase. Passing true as the third argument to addEventListener uses Capturing phase. stopPropagation() halts propagation; preventDefault() prevents default browser behaviour (they are NOT the same). Candidates call stopPropagation() expecting it to prevent form submission — that requires preventDefault().
Frequently Asked Questions
- What is the Salesforce JavaScript Developer I exam format?
- The Salesforce JavaScript Developer I exam has 60 multiple-choice questions, a 105-minute time limit, a 65% passing score, and a $200 fee ($100 retake). It tests JavaScript language fundamentals, browser APIs, Node.js basics, testing, and Lightning Web Components (LWC).
- What are the highest-weight JavaScript Developer I exam sections?
- JavaScript Fundamentals (23%) and Lightning Web Components (25%) together account for 48% of the exam. Variables, closures, promises, async/await, the event loop, and LWC component lifecycle are the most heavily tested topics.
- Do I need Apex knowledge for JavaScript Developer I?
- The exam primarily tests JavaScript, not Apex. However, you need to understand how LWC components interact with Apex — wire adapters, imperative Apex calls, and how @AuraEnabled methods work. Deep Apex coding knowledge is not required but understanding the Apex-LWC boundary is.
- What is the hardest part of the JavaScript Developer I exam?
- Asynchronous JavaScript (Promises, async/await, event loop execution order) and LWC lifecycle hooks are the most frequently cited challenges. Candidates who only know JavaScript superficially — without understanding closures, prototype chain, and the event loop — struggle with the trick questions in these areas.
- What concepts do most JavaScript Developer I candidates get wrong?
- The most commonly misunderstood topics for the JavaScript Developer I exam are: (1) Promises vs Async/Await — Same Mechanism, Different Syntax; (2) var vs let vs const — Scope and Reassignment Rules; (3) Event Bubbling vs Capturing — Two Phases of DOM Event Propagation. Candidates are most confidently wrong on these — learn the distinctions early to avoid losing marks on questions you expect to get right.
- Why do most Javascript Developer I candidates fail questions about Promises vs Async/Await?
- Promises and async/await both handle asynchronous operations — async/await is syntactic sugar over Promises. A function marked async always returns a Promise. await pauses execution until the Promise resolves. Candidates treat these as entirely different mechanisms and struggle with error handling: rejected Promises in async/await are caught with try/catch, not .catch(). Know both patterns and ...
- Why do most Javascript Developer I candidates fail questions about var vs let vs const?
- var is function-scoped and hoisted (available before its declaration line at runtime, with value undefined). let is block-scoped and not accessible before declaration (temporal dead zone). const is block-scoped and cannot be reassigned (but the object it references can be mutated). Candidates use var for all declarations — the exam expects let for mutable block-scoped variables and const for va...
- Why do most Javascript Developer I candidates fail questions about Event Bubbling vs Capturing?
- Events propagate in two phases: Capturing (top-down, from document to target) then Bubbling (bottom-up, from target back to document). addEventListener defaults to Bubbling phase. Passing true as the third argument to addEventListener uses Capturing phase. stopPropagation() halts propagation; preventDefault() prevents default browser behaviour (they are NOT the same). Candidates call stopPropag...
Related Exam Tips
Start JavaScript Developer I Prep
After this exam, consider Platform Developer II or Platform App Builder next.