New to this track? Our Salesforce Certified Platform Developer exam prep is the recommended first step. See our certification path to understand where this certification fits. The Salesforce Certified JavaScript Developer exam weights Objects, Functions, and Classes most heavily (25%), see the full breakdown, study tips, and practice questions below.
Free practice • No sign-up required
$200 exam • 65% passing score • Free practice
Independent study resource
Exam objectives and policies can change. Confirm current details with the certification issuer.
Check current objectives
Use the official exam guide as the source for current objectives and section weights.
Practice for learning
Use sample questions to review concepts and identify topics for further study.
Works on Any Device
Full practice experience on phone, tablet, or desktop
Free, No Sign-Up
Start practicing immediately, no account or email required
Salesforce Certified JavaScript Developer – Complete 2026 Guide
Core JavaScript and the Lightning Web Components model: ES6 syntax, scope and closures, prototypes, promises and async/await, the event loop, the web component standards LWC is built on, calling Apex, and Lightning Web Security. The exam is 60 scored questions in 105 minutes, with a 65% pass mark, weighted towards Objects, Functions, and Classes (25%) and Variables, Types, and Collections (23%).
Recommended Prerequisites
We recommend completing this certification first to prepare you better.
| Official exam name and code | Salesforce Certified JavaScript Developer (JS Developer I) |
|---|---|
| Questions | 60 |
| Time allotted | 105 min |
| Passing score | 65% |
| Exam fee | $200 |
| Retake fee | $100 |
| Prerequisite certifications | Recommended preparation: Salesforce Certified Platform Developer |
| Study guide release | Summer '26 |
Salesforce Certified JavaScript Developer Exam Weightage by Section
1. Variables, Types, and Collections (23%)
23%2. Objects, Functions, and Classes (25%)
25%3. Browser and Events (17%)
17%4. Debugging and Error Handling (7%)
7%5. Asynchronous Programming (13%)
13%6. Server Side JavaScript (8%)
8%7. Testing (7%)
7%Exam Topics
Last updated:
Who is the JavaScript Developer I exam for?
- Web developers moving into Salesforce: Your JavaScript is already good. What you need is the component model, the Apex boundary and the security rules.
- Salesforce developers who came from Apex: This is the exam that exposes self-taught JavaScript. The language half is where the marks go, not the LWC half.
- Anyone who writes Lightning Web Components: Whether or not you want the credential, the syllabus is a reasonable list of what you should know to write components that behave.
Exam Fees & Registration
Exam Fee
$200
One-time registration fee
Retake Fee
$100
If you need to retake the exam
Comparing certs? View all Salesforce exam fees in one place →
Certification Validity
Maintenance and renewal requirements vary. Check the issuer’s current credential page for requirements that apply to you.
How to Register
Check current Salesforce Certified JavaScript Developer (CRT-600) credential and registration details with the issuer.
View official credential detailsOfficial references: Use the issuer’s current materials to confirm exam objectives, format, and fees before booking.
Official sources: Exam guide·Salesforce exam pricing·Independent exam-prep resource; details may change.
Exam Tips
- 1LWC and Aura are 30%. Know component lifecycle, decorators, and events.
- 2JavaScript fundamentals: ES6+, async, DOM, and debugging.
- 3Understand when to use LWC vs Aura and migration considerations.
- 4Testing: Jest for LWC, and debugging in browser and VS Code.
Prerequisites
- •JavaScript experience
- •Platform Developer I recommended
Focus Areas
- •JavaScript Fundamentals
- •LWC and Aura
- •Debugging and Testing
- •Performance
Study Strategy
Build at least two LWCs (one with Apex).
Practice debugging and unit testing.
Memorize key decorators and lifecycle hooks.
Exam Format and First-Attempt Readiness
The Salesforce Certified JavaScript Developer exam has 60 questions in 105 min, passing score 65%. Most Salesforce exams test scenario-based decisions. Focus on when to use each feature, not just terms.
- Study Objects, Functions, and Classes and Variables, Types, and Collections first, together they carry 48% of the exam.
- Do timed question sets. Build pacing and confidence.
- Review why wrong answers are wrong. It improves scenario reasoning.
- Book the exam once your mock scores are steady at 75%+.
Is the JavaScript Developer I Exam Hard?
Is the JavaScript Developer I Exam Hard?
A JavaScript exam that happens to run on Salesforce. Most of it is language fundamentals: scope, closures, prototypes, promises, the event loop, and reading code to say what it prints. The Salesforce content is real but smaller. Platform developers who learned JavaScript as they went tend to find this harder than they expect.
- 60 questions in 105 minutes. Code-reading questions eat time, so do not spend five minutes on one snippet.
- 65% to pass, leaving roughly 19 you can get wrong.
- Execution order is the recurring theme. Promises are microtasks, setTimeout is a macrotask, and a snippet mixing them is a near certainty.
- The LWC half is lifecycle and data. connectedCallback against renderedCallback, wire against imperative Apex, and how events cross the shadow boundary.
Pass Rate Guidance
Open a console and predict the output before you run it. Closures in loops, a promise chain with a setTimeout in the middle, this inside a regular function against an arrow function. If you get those right consistently, the exam will not surprise you. If not, that is where to spend your week.
JavaScript Developer I Exam Format Explained
JavaScript Developer I Exam Format Explained
Proctored online or at a test centre. The shape of it:
Total Questions
60 scored questions
Time Limit
105 min
Passing Score
65%
Question Type
Multiple-choice & multiple-select
How Many Questions Are Scenario-Based?
Close to half the questions involve code. Usually it is a snippet with a question about what it logs, in what order, or why it throws. The rest is choosing the right decorator, lifecycle hook or async pattern for a stated requirement.
Best Way to Pass on Your First Attempt
- Write the code, do not read about it. Every topic on this syllabus can be tested in a browser console in under a minute. Guess the output first, then run it.
- Learn the event loop properly. Call stack, microtask queue, macrotask queue. Once you can place a promise callback and a setTimeout callback on the right queue, the ordering questions become mechanical.
- Know what this binds to in each case. Method call, standalone function, arrow function, callback passed to another function. Four cases, asked repeatedly.
- Build one component that calls Apex both ways. Once with wire, once imperatively from a button. The difference between them stops being abstract.
JavaScript Developer I: Key Concepts
Scope, Closures and this
A closure is a function that keeps access to the variables of the scope it was created in, even after that scope has returned. It is the mechanism behind private state, factory functions and most callback bugs. The classic exam case is a loop that creates functions: with var, every function shares one binding and they all see the final value, while let creates a fresh binding each iteration and they see what you expected. Separately, this is decided by how a function is called rather than where it is written. Called as a method, this is the object. Called standalone, it is undefined in strict mode. In an arrow function, there is no own this at all, so it comes from the enclosing scope, which is exactly why arrow functions are used for callbacks that need the surrounding context. Expect a snippet where a method is passed as a callback and loses its binding.
Prototypes and Classes
JavaScript inheritance works through a chain of objects. Every object has a prototype, and a property lookup walks up that chain until it finds the property or runs out. Class syntax is a cleaner way of writing the same thing: a class body defines methods on the prototype, extends sets up the chain, and super calls the parent. Two details are examinable. Methods defined in the class body live on the prototype and are shared across instances, whereas properties assigned in the constructor belong to each instance. And instanceof asks whether a prototype appears anywhere in an object's chain, which is why it answers true for an inherited type as well as the exact one.
Promises, async/await and Error Handling
A promise is an object representing a result that has not arrived. It settles once, either resolved or rejected, and then handlers registered with then, catch and finally run. Chaining matters because each then returns a new promise, so returning a value passes it along and returning a promise waits for it. async and await are syntax over the same thing: an async function always returns a promise, and await pauses inside it until the awaited promise settles. For error handling, a rejection travels down a chain until something catches it, and an uncaught rejection is a silent failure you should treat as a bug. The combinators get asked by behaviour: Promise.all rejects as soon as any input rejects, Promise.allSettled always resolves and reports each outcome, and Promise.race settles with whichever finishes first.
The Event Loop
JavaScript runs one thing at a time. Synchronous code runs to completion on the call stack. When the stack empties, the runtime drains the microtask queue, which is where promise callbacks go; and only then takes one task from the macrotask queue, which is where setTimeout and setInterval callbacks go. That ordering is the whole answer to most execution-order questions: all synchronous logging first, then promise callbacks, then timer callbacks, even a setTimeout with a delay of zero. It is also why a long synchronous loop freezes the page, since nothing else can run until the stack clears. Knowing this one model well is worth more marks than any other single topic on the exam.
Lightning Web Components: Lifecycle, Apex and Security
LWC is built on web component standards, so a component is a custom element with its own shadow tree. The lifecycle hooks have specific moments: constructor runs before the component is in the DOM and must not touch it, connectedCallback runs when it is inserted and is where you start work that does not need rendered markup, renderedCallback runs after every render and so must guard against repeating itself, and disconnectedCallback is where you clean up subscriptions and listeners. For data, the wire service is declarative and reactive: it fetches when its parameters change and is right for reading. Imperative calls are made from JavaScript when you need control over timing, such as on a button click, or when the call changes data. Events travel up: by default an event raised inside a shadow tree does not cross the boundary unless it is created with composed true, which is why custom events are usually handled by the immediate parent. Lightning Web Security replaced LockerService and restricts what component code can reach, including direct DOM access outside the component's own tree.
LWC source is written once, but two different JS engines run it at two different times: Node.js compiles/bundles and runs Jest tests at build time; the browser executes the compiled component, handles the Shadow DOM, and fires lifecycle hooks at runtime.
How to Pass the Salesforce JavaScript Developer I Exam
Treat the language half as the exam and the platform half as a supplement. Nearly everything here is testable in a console in under a minute.
Predict, Then Run
Write snippets, guess the output, then execute. This single habit covers closures, hoisting, this binding and execution order.
The Three Queues
Call stack, then microtasks, then one macrotask. Promise callbacks beat setTimeout every time, including setTimeout zero.
Four Cases for this
Method call, standalone call, arrow function, and a method passed as a callback. Know what this is in each.
Promise Combinators by Behaviour
all rejects fast, allSettled never rejects, race settles first. Questions describe the behaviour rather than naming the method.
Lifecycle Hooks by Timing
connectedCallback for setup without the DOM, renderedCallback after every render so guard it, disconnectedCallback for cleanup.
Is the Salesforce Certified JavaScript Developer (CRT-600) Exam Hard?
DifficultyModerate; plan about 4-8 weeks of focused prep.
Book When ReadyScore 75%+ on three timed mocks before scheduling.
Use Practice, Not DumpsOriginal practice questions build skill without risking your credential.
Exam format: 60 questions, 105 min, 65% passing score.
Salesforce Certified JavaScript Developer Practice Questions (With Explanations)
Test your knowledge with these 15 sample questions.
Question 1: Which JavaScript feature is used to handle asynchronous operations without blocking the main thread?
Key takeaway: Promises and async/await are the modern JavaScript approach for handling asynchronous operations.
Show correct answer and explanation
Correct answer: C. Promises and async/await
Promises and async/await are the modern JavaScript approach for handling asynchronous operations.
- Synchronous loops block the main thread, the opposite of what's needed for async handling.
- var is a variable declaration keyword, unrelated to asynchronous operations.
- Callbacks alone are an older async pattern; Promises/async-await are the modern standard tested on this exam.
Question 2: What is the primary use of Lightning Web Components (LWC) in the Salesforce ecosystem?
Key takeaway: LWC is the standard for building performant, reusable UI components on the Salesforce Lightning Platform.
Show correct answer and explanation
Correct answer: C. Building reactive UI components that run on the Lightning Platform
LWC is the standard for building performant, reusable UI components on the Salesforce Lightning Platform.
- Email templates are unrelated to LWC's purpose as a UI component framework.
- Data modeling is a separate concern from building UI components.
- LWC runs on the client (browser) side, not as backend Apex logic.
Question 3: Which keyword creates a block-scoped variable in JavaScript?
Key takeaway: let (and const) create block-scoped variables; var is function-scoped.
Show correct answer and explanation
Correct answer: A. let
let (and const) create block-scoped variables; var is function-scoped.
- function declares a function, not a variable.
- var is function-scoped, not block-scoped; this is precisely why let/const were introduced.
- 'global' is not a JavaScript variable declaration keyword.
Question 4: What does the shadow DOM provide in web components?
Key takeaway: Shadow DOM provides style and markup encapsulation so component internals don't leak out.
Show correct answer and explanation
Correct answer: A. Encapsulation of styles and markup
Shadow DOM provides style and markup encapsulation so component internals don't leak out.
- Shadow DOM doesn't manage database access.
- Shadow DOM has nothing to do with API keys or security credentials.
- Shadow DOM is a client-side browser feature, unrelated to server-side rendering.
Question 5: Which LWC decorator makes a property available to the component's template?
Key takeaway: @api exposes a public property that can be set by a parent component.
Show correct answer and explanation
Correct answer: A. @api
@api exposes a public property that can be set by a parent component.
- @invocable is not an LWC decorator, it's unrelated to component properties.
- @track is used for reactive private property tracking, not for exposing properties to the template/parent.
- @wire is used for provisioning data from Salesforce, not for exposing properties externally.
Question 6: Which LWC wire adapter is used to get a record by Id?
Key takeaway: getRecord wire adapter fetches a record by Id with specified fields.
Show correct answer and explanation
Correct answer: C. getRecord
getRecord wire adapter fetches a record by Id with specified fields.
- getListUi retrieves a list of records, not a single record by Id.
- getObjectInfo retrieves object metadata, not record field data.
- createRecord creates a new record, it doesn't retrieve an existing one.
Question 7: What does the spread operator (...) do in JavaScript?
Key takeaway: The spread operator expands arrays or copies/merges object properties.
Show correct answer and explanation
Correct answer: D. Expands iterables or copies/merges objects
The spread operator expands arrays or copies/merges object properties.
- The spread operator doesn't create classes.
- The spread operator doesn't handle errors, that's the role of try/catch.
- The spread operator doesn't delete properties, rest/destructuring with omission handles that differently.
Question 8: Which LWC lifecycle hook runs when the component is inserted into the DOM?
Key takeaway: connectedCallback runs when the component is added to the DOM.
Show correct answer and explanation
Correct answer: B. connectedCallback
connectedCallback runs when the component is added to the DOM.
- renderedCallback fires after every render, not specifically on initial DOM insertion.
- disconnectedCallback fires when a component is removed from the DOM, not inserted.
- errorCallback fires when a descendant component throws an error, unrelated to DOM insertion.
Question 9: What is the purpose of @wire in LWC?
Key takeaway: @wire reactively fetches data when parameters change.
Show correct answer and explanation
Correct answer: B. To reactively fetch data or call Apex imperatively with reactive parameters
@wire reactively fetches data when parameters change.
- @wire itself doesn't track state, that's the role of @track or reactive properties.
- @wire doesn't directly handle DOM events, that's done with event listeners.
- @wire is for provisioning data, not for exposing properties to templates (that's @api).
Question 10: Which JavaScript method creates a new array from another without mutating the original?
Key takeaway: map and slice return new arrays; they don't mutate the original.
Show correct answer and explanation
Correct answer: B. map or slice
map and slice return new arrays; they don't mutate the original.
- push mutates the original array by adding to it.
- splice mutates the original array in place.
- pop mutates the original array by removing its last element.
Question 11: What does event.target refer to in a DOM event handler?
Key takeaway: event.
Show correct answer and explanation
Correct answer: A. The element that dispatched the event
event.target is the element that triggered the event.
- event.target is not the window object; window is the global browsing context.
- event.target refers to the specific element that fired the event, not the whole document.
- event.target is not the parent element; that would require traversing the DOM tree separately.
Question 12: Which Aura component attribute type is similar to @api in LWC?
Key takeaway: aura:attribute with public/global access exposes data like @api.
Show correct answer and explanation
Correct answer: B. aura:attribute with access='global' or 'public'
aura:attribute with public/global access exposes data like @api.
- aura:method exposes a callable method, not a data property equivalent to @api.
- aura:handler registers event handling logic, not a component-facing property.
- aura:registerEvent is used to declare that a component can fire an event, not to expose a property.
Question 13: What is a JavaScript module?
Key takeaway: Modules export bindings and provide encapsulation via import/export.
Show correct answer and explanation
Correct answer: C. A file that exports bindings for reuse and encapsulates code
Modules export bindings and provide encapsulation via import/export.
- A module isn't limited to a single variable; it can export multiple bindings.
- A JavaScript module can contain more than a single class, it's a broader unit of code organization.
- A module isn't limited to functions alone; it can export any bindings.
Question 14: Which LWC method is used to navigate programmatically?
Key takeaway: NavigationMixin.
Show correct answer and explanation
Correct answer: D. NavigationMixin.GeneratePage
NavigationMixin.GeneratePage enables programmatic navigation in LWC.
- history.push is a browser history API concept, not the LWC-specific navigation method.
- NavigationMixin is in fact the standard way LWC handles programmatic navigation, this option incorrectly denies its use.
- window.location causes a full page reload, which isn't the LWC-recommended navigation approach.
Question 15: What does const prevent in JavaScript?
Key takeaway: const prevents reassignment; object/array contents can still be mutated.
Show correct answer and explanation
Correct answer: D. Reassignment of the variable binding (but not mutation of objects)
const prevents reassignment; object/array contents can still be mutated.
- const has nothing to do with block scope, that behavior comes from let and const equally, not from preventing scope.
- const doesn't prevent variable declaration, it's a way of declaring variables.
- const does not prevent mutation of the contents of objects/arrays, only reassignment of the binding itself.
Get the Full CRT-600 Question Bank
Most candidates book the exam after scoring 75%+ on full mocks.
If you’re planning to test this quarter, aim to complete full mocks at least 10–14 days before your exam date.
Contact us for more information on our full 60-question mock exams and a personalized study plan. Use the contact form.
Request Mock Exams & Study PlanSalesforce Certified JavaScript Developer (CRT-600) Exam FAQs
- What is covered on the Salesforce Certified JavaScript Developer (CRT-600) exam?
- The Salesforce Certified JavaScript Developer (CRT-600) exam (formerly Salesforce Certified JavaScript Developer I) covers section-wise weightage as shown above. Use the exam topics and practice questions on this page to align your study with the official outline.
- Do I need Platform Developer I before JavaScript Developer I?
- While not required, Platform Developer I is highly recommended. JavaScript Developer I focuses specifically on JavaScript, LWC, and Aura, so having PD1 knowledge helps, but you can take it independently if you have strong JavaScript skills.
- What JavaScript concepts are most important for JavaScript Developer I?
- Focus on ES6+ features (arrow functions, promises, async/await), DOM manipulation, JavaScript debugging, LWC lifecycle hooks and decorators, and testing with Jest. The exam is heavily JavaScript-focused.
- Are there free practice questions for the Salesforce Certified JavaScript Developer (CRT-600) exam?
- Yes. This page includes free sample practice questions with explanations. Use them alongside the current official documentation.
- How do I prepare for the Salesforce Certified JavaScript Developer (CRT-600) certification?
- Use the exam tips, prerequisites, and study strategy on this Salesforce Certified JavaScript Developer (CRT-600) study guide (formerly Salesforce Certified JavaScript Developer I). Focus first on the highest-weighted sections, then take the sample practice questions. Schedule the exam when you consistently score well on practice tests.
Next Certifications After Developer
Where developers usually go next:
Honest Cert Breakdown
Difficulty: Hard
4/5LWC, JavaScript ES6+, Salesforce DX, testing with Jest. Requires genuine frontend development experience, not a study-your-way-through cert.
Salary Range
$102,000–$142,000 / year
US average for certified professionals • Updated Summer '26 • Source: Salesforce Talent Ecosystem
Is it worth it?
Good differentiation for Salesforce developers who work on complex UI. Pairs naturally with Platform Developer I.
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.
Topic Difficulty Heatmap
Which topics are a gimme vs which ones trap confident candidates. Use this to prioritise your final-week revision. These are our own topic groupings for study planning, not the official exam sections, those and their weightings are in the credential's exam guide.
| Topic | 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 QuestionsQuick 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.
Share or cite this study guide
Free to link from a forum post, study repo or article. Copy the Markdown and paste it anywhere.