Exam Overview: Exam Map and Study Plan

Exam Map & Study Plan 0:00

Welcome to the Salesforce Certified JavaScript Developer course. This is part zero: the exam map and study plan. Before we write any code, we look at what the exam is, how it is weighted, how its questions think, and the plan for the next six weeks. This is a from scratch route to passing, for a developer who already writes some JavaScript. The exam asks you to do three things. Predict what code does. Choose the right tool. And fix what's broken. Every lesson in this course trains one of those three skills. An honest starting point: this course is exam shaped, so it assumes you have written JavaScript before.

Know the exam before you study for it 0:41

Part zero has one goal: know the exam before you study for it. Here are the headline numbers. Sixty scored questions, seven domains, and twenty four objectives. We will cover it in six short parts. One, the exam at a glance. Two, the fixed bar you have to clear. Three, the seven domain map. Four, where to spend your time. Five, how the questions think. And six, your six week plan. Each part ends with a decision you can act on. By the end, you will be able to say how many questions each domain brings, and where your hours go.

Sixty scored questions, 105 minutes, one fixed pass mark 1:22

First, the exam at a glance. Sixty scored questions, one hundred and five minutes, and one fixed pass mark. The exam has sixty scored questions, plus up to five unscored ones. You get one hundred and five minutes. You need sixty five percent to pass. And the objectives align to the Summer twenty two release. The format is multiple choice and multiple select. There is no required prerequisite, and no credential is required first. The guide does recommend one to two years developing front end or back end JavaScript. One practical rule. You cannot tell which questions are scored and which are not, so treat every question as scored.

A pass mark of 65%, every time 2:03

A quick jargon check on the pass mark. It is sixty five percent, every time. The exam guide states the sixty five percent pass mark. With sixty scored questions, that works out to about thirty nine correct. That figure is our own arithmetic, sixty times point six five, so use it as a planning number rather than an official one. Why does this matter? Because you can miss about a third of the questions and still pass. So plan for breadth over perfection.

Your study map is also a time budget 2:32

Now the seven domain map. Your study map is also a time budget. Objects, Functions, and Classes is the biggest domain, at twenty five percent. That is about fifteen of the sixty questions. Variables, Types, and Collections is twenty three percent, about fourteen questions. Browser and Events is seventeen percent, about ten questions. Asynchronous Programming is thirteen percent, about eight. Server Side JavaScript is eight percent, about five questions. And Debugging and Error Handling, and Testing, are seven percent each, about four questions apiece. A note on the numbers. The guide publishes weights, not question counts. The counts are our arithmetic: sixty times the weight. Read the bars top to bottom, and let them guide where you spend your attention.

Half the exam is two domains 3:22

This is the biggest lever in your study plan. Half the exam is two domains. Objects, Functions, and Classes plus Variables, Types, and Collections add up to forty eight percent of the exam. That is about twenty nine questions. The other five domains make up fifty two percent, about thirty one questions. Twenty five plus twenty three is forty eight percent. That is why the first two modules are the longest. A practical rule. If time is short, over invest in those first two domains. But don't skip any. Every domain has questions you can win.

No prerequisite, but real JavaScript assumed 3:59

Next, eligibility versus readiness. There is no prerequisite, but real JavaScript is assumed. You can sit the exam with no prerequisite at all. But to reason well, the guide recommends one to two years developing front end or back end JavaScript. The skills are core JavaScript, usable in any framework, including Lightning Web Components. They are not mobile or device specific. The guide's audience is partners, customers, and employees who work with JavaScript. So what does readiness mean? It means being able to predict what short code does, and to pick the right A P I, command line command, or library for a stated requirement.

Read the code. Predict. Then choose 4:41

Now, how the questions think. Read the code. Predict. Then choose. Every question gives you a situation: a requirement, or a short snippet of code. You make a decision: the output, the error, the A P I, the command, or the fix. And the wrong options are never random. Each wrong option is a real misreading. That is how you learn to eliminate them. Look at how the objectives are worded. They start with phrases like, given a scenario, given a business requirement, or, with a block of code. So this is not a definition quiz. The skill is applying rules to a situation, not reciting them.

Predict it, pick it, or fix it 5:23

Almost every objective fits one of three question shapes. Predict it, pick it, or fix it. Predict questions ask what code will do. Think scope, coercion, hoisting, and the event loop. Pick questions ask you to choose the right tool. An array method, a browser A P I, a Node module, a command line command, or a package manager. Fix questions ask you to repair something. An error handler, a failing test, or a missing await. A practical rule for each. For predict questions, trace the code line by line. For pick questions, match the requirement to the documented purpose. And for fix questions, find what can fail. We practice all three shapes in every module.

Seven modules, one lesson per objective 6:11

Here is the course map. Seven modules, one lesson per objective. Module one is Variables, Types, and Collections: six lessons. Module two is Objects, Functions, and Classes: five lessons. Module three covers Browser and Events: four lessons. Module four is Debugging and Error Handling: two lessons. Module five is Asynchronous Programming: two lessons. Module six is Server Side JavaScript: four lessons. And module seven is Testing: one lesson. That is twenty four lessons in all.

A repeatable rhythm turns rules into judgment 6:48

Every lesson teaches in the same repeatable rhythm. It turns rules into judgment. Rule. We state the documented behavior, one idea at a time. Trace. We step through code line by line, and in the labs you predict before you run. Trap. We show the tempting wrong answer, and why it is wrong. And proof. You answer practice questions, closed book. Why does this work? You meet each rule before you are asked to use it, and then you are tested on it.

Four things, each with a job 7:23

You have a toolkit of four things, and each has a job. The lesson videos give you the walkthrough of every objective. The cited notes are the reference, and every fact in them has a source. The practice bank has two hundred and ninety nine questions across all seven domains. And there are three timed mock exams, built to the real weights. The rule to remember: the video explains, the notes prove, and the bank tests. Use them in that order for each lesson.

One module a week, then mocks 7:53

Now your plan. One module a week, then mocks. Week zero is orientation and a diagnostic quiz, to give you a baseline score. Week one is Variables, Types, and Collections, ending with checkpoint one. Week two is Objects, Functions, and Classes, with checkpoint two. Week three covers Browser and Events, and Debugging, with checkpoints three and four. Week four is Asynchronous Programming, with checkpoint five and your first mock. Week five is Server Side JavaScript and Testing, with checkpoints six and seven, and mock two. Week six is targeted review, mock three, and a go or no go decision. The pacing is about eight hours a week, and that is a suggestion. If you have more time, spend it on weeks one and two. They carry nearly half the exam.

A mock is built the way the exam is built 8:44

The proof of readiness is a mock exam, and a mock is built the way the real exam is built. Sixty questions, split by the weights. Fourteen on variables, fifteen on objects, ten on the browser, eight on async, five on server side, four on debugging, and four on testing. They are timed at one hundred and five minutes. You take three mocks. Mock one, at the end of week four, with a suggested target of seventy percent or better. Mock two, at the end of week five, seventy five percent or better. And mock three, in week six, eighty percent or better. The go or no go rule is simple. Mock three at eighty percent or better, with no domain under seventy percent. These targets are suggestions, and they are deliberately above sixty five percent, to leave a safety margin.

About 1¾ minutes per question 9:35

A few exam day habits. You have about one and three quarter minutes per question. One hundred and five minutes divided by sixty questions is about one point seven five minutes each. Predict first, then read the options. On a choose two question, judge each option on its own, and check both. Trace code line by line, and don't pattern match on a familiar A P I. And if a question is eating your time, mark it and move on. Come back with time left. One practical rule. When two options look alike, find the one detail that differs. That is usually the tested rule. And multiple select questions need exactly the right set, so judge each option on its own.

A developer at Ursa Major Solar runs the following code. What is the result? 10:19

Let's see the method in action with a practice question from the question bank. Pause the video, and predict the result first, before you read the options. A developer at Ursa Major Solar runs the code shown. What is the result? Option A: Acme is logged. Option B: a Type Error is thrown on the assignment. Option C: Globex is logged. Option D: a Syntax Error is thrown when the script loads. Pause now, and make your prediction. The answer is on the next slide.

Globex is logged: const locks the binding, not the contents 10:52

The answer is C. Globex is logged. Const locks the binding, not the contents. The assignment changes a property of the object. It never points the variable at a new object. Properties can change under const. Now the wrong options. A assumes the assignment is ignored. But mutation succeeds, so the old value is gone. B says a Type Error. That error comes from reassigning the variable itself, such as account equals an empty object, not from changing a property. And D says a Syntax Error. That comes from a const with no initializer. This one has an initializer. The takeaway: every wrong option is a real misreading. Naming the misreading is how you rule it out. We cover all of this in module one.

Now start with the biggest domain pair 11:41

That completes the bridge. You now have the exam map, the question shapes, and your plan. Next we start with the biggest domain pair, beginning with module one: Variables, Types, and Collections. The first lesson is Creating and Initializing Variables. Before you go, take the twenty question diagnostic, closed book, and write down your score for each domain. See you in lesson one.