Salesforce JavaScript Developer I Study Guide (Winter '26)
Your complete guide to passing the JavaScript Developer I exam — ES6+, async programming, OOP, DOM events, testing, and free practice questions.
Written and reviewed by Krishna Mohan — ADM-201, PD1, PD2, App Builder & Consultant certified. Updated for Winter '26. Methodology · Contact
Exam Sections & Weightings
What Each Section Tests
Variables, Data Types & Collections
var vs let vs const, scope (block, function, global), hoisting, primitive types (string, number, boolean, null, undefined, symbol, BigInt), arrays, Maps, Sets, and WeakMaps.
Objects, Functions & Classes
Object literals, prototypal inheritance, ES6 classes, constructors, getters/setters, static methods, arrow functions, closures, IIFE, higher-order functions, and the module pattern.
Browser & Events
DOM manipulation (querySelector, createElement, appendChild), event listeners, event bubbling vs capturing, event delegation, the browser event loop, and Web APIs (fetch, localStorage, setTimeout).
Asynchronous Programming
Promises (then/catch/finally, Promise.all, Promise.race), async/await syntax, the call stack and event queue, microtask vs macrotask queue, and error handling in async code.
Debugging & Error Handling
try/catch/finally, custom Error types, error propagation, using browser DevTools (breakpoints, watch expressions, call stack), console methods, and understanding stack traces.
Server-Side JavaScript & Testing
Node.js basics (require/import, npm, package.json), Jest testing framework (describe, it, expect, mocks), unit testing functions and async code, and common testing patterns.
6-Week Study Plan
Scenario Strategy Tips
- 1.Scope and hoisting traps: var declarations are hoisted to the top of their function scope; let and const are hoisted to their block scope but not initialised (temporal dead zone). Many exam questions present code and ask what it outputs — trace through hoisting first.
- 2.Promise chaining vs async/await: Both are tested. Know that async functions always return a Promise, that await unwraps the Promise value, and that errors in async functions must be caught with try/catch. Know that Promise.all() rejects if ANY promise rejects.
- 3.Event bubbling vs capturing: Events bubble from the target element up to the document. Event capturing goes down from the document to the target. addEventListener's third argument (true = capture, false = bubble, default). Event.stopPropagation() stops the phase; Event.preventDefault() blocks default browser behaviour.
- 4.this keyword context: In a regular function, this is determined by how the function is called. Arrow functions inherit this from their enclosing lexical scope. This distinction is commonly tested in class method and callback scenarios.
Mock Exam Benchmark
Aim for 75%+ on practice exams before scheduling. Objects, Functions & Classes (25%) and Variables (23%) together account for nearly half the exam — master scope, closures, and ES6 class syntax first. Many exam questions show a code snippet and ask what it outputs, so trace through execution order carefully.
Top 10 Concepts to Review
- var vs let vs const — scope, hoisting, temporal dead zone
- Closures — function remembering its outer scope variables after outer function returns
- ES6 classes: constructor, inheritance (extends/super), static methods, getters/setters
- Arrow functions — no own this, no arguments object, implicit return
- Destructuring: object and array syntax — pulling values from objects and arrays into variables
- Promises: then/catch/finally chains, Promise.all, Promise.race, Promise.allSettled
- async/await: error handling with try/catch, parallel execution with Promise.all
- Event bubbling vs capturing and event.stopPropagation vs preventDefault
- Prototype chain and prototypal inheritance (Object.create, __proto__)
- Jest testing: describe/it/expect, .toBe vs .toEqual, mocking with jest.fn()
Frequently Asked Questions
- What is the Salesforce JavaScript Developer I certification?
- The Salesforce JavaScript Developer I certification validates JavaScript skills relevant to building Salesforce Lightning Web Components (LWC) and client-side solutions. It tests JavaScript fundamentals, ES6+ features, asynchronous programming, browser APIs, and testing — not Salesforce-specific APIs. The exam has 60 questions, 105 minutes, ~65% passing score, and a $200 fee.
- Do I need Salesforce experience for the JavaScript Developer I exam?
- The JavaScript Developer I exam does not require prior Salesforce experience. It tests JavaScript language skills directly — most questions are about vanilla JavaScript, not Salesforce-specific APIs like apex or wire decorators. However, the certification is intended for developers who will use JavaScript in a Salesforce context (LWC, Visualforce, custom apps).
- How is JavaScript Developer I different from Platform Developer I (PD1)?
- PD1 tests Salesforce-platform skills: Apex, Visualforce, Lightning components, governor limits, and Salesforce data model. JavaScript Developer I tests pure JavaScript language skills: ES6+, asynchronous programming, OOP with classes, browser DOM, and testing. Many developers take both — PD1 for Salesforce back-end, JS Dev I for front-end JavaScript skills.
- What ES6+ features are tested on the JavaScript Developer I exam?
- Key ES6+ features tested include: arrow functions, destructuring (object and array), template literals, default parameters, rest and spread operators, classes and inheritance, let/const vs var, Promises and async/await, modules (import/export), Map and Set collections, and Symbol. Focus especially on how each ES6 feature differs from its ES5 equivalent.
- How long should I study for the JavaScript Developer I exam?
- Plan for 6–8 weeks with 8–12 hours per week. Candidates with strong JavaScript experience can prepare in 4 weeks. The best preparation is writing code — build small projects using each concept (a Promise chain, an ES6 class hierarchy, an event-driven DOM app) rather than only reading documentation. Use the browser DevTools console to test snippets.
Compare Certifications
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 |
|---|---|---|
| JavaScript Fundamentals | Moderate | ES6+ syntax, promises, and closures — code snippets often test subtle behaviour. |
| LWC and Aura | Trap ⚠ | LWC vs Aura lifecycle and when to use which — decorators and wire vs imperative. |
| Debugging and Testing | Hard | Jest for LWC and debugging techniques — async and mock patterns are tested. |
| Performance and Security | Moderate | Locker Service and performance best practices — know the security boundaries. |
Difficulty based on analysis of common candidate errors across each exam section.
Ready to Practice?
Test yourself with free JavaScript Developer I practice questions covering all 6 exam sections.
Start Free Practice Questions