98-382 Exam Guide: What the JavaScript MTA Exam Validated and What Candidates Should Do Now
Microsoft Exam 98-382 was the MTA: Introduction to Programming Using JavaScript exam, an entry-level credential for learners beginning a technology career or adding technical foundations to a business career. It is no longer an available path for new candidates because Microsoft retired MTA exams on June 30, 2022. This guide helps you make the important decision first: whether you are preserving evidence of an older achievement or choosing a current learning and certification route instead of studying for an unavailable exam.
Can you still take Exam 98-382?
No. Exam 98-382 belonged to Microsoft Technology Associate, or MTA, a program Microsoft retired on June 30, 2022. Microsoft states that retired exams cannot be taken and that their associated certification or credential cannot be earned after retirement. A preparation plan for a new 98-382 attempt therefore cannot lead to a current Microsoft certification.
The retirement date is not a minor scheduling detail. Microsoft’s retirement FAQ states that candidates had until June 30, 2022 to register for and take an MTA exam, and that MTA exams could not be retaken after that date. Microsoft also stopped offering MTA exam licenses for purchase after June 30, 2021. Do not spend time looking for a new voucher, appointment, or retake option for this exam.
If a website presents 98-382 dumps as a way to obtain the credential now, treat that as a warning sign. Memorizing leaked or purported exam questions cannot restore a retired exam, and it does not establish practical JavaScript ability. The useful value of 98-382 preparation today is historical understanding, skills practice, or verification of an exam already passed—not a new certification attempt.
What did 98-382 represent?
98-382 was Microsoft’s MTA: Introduction to Programming Using JavaScript exam. The MTA program was positioned as entry-level training and certification covering technology fundamentals. Microsoft described MTA certifications as suitable for people beginning technology careers or enhancing business careers, so the intended audience was broader than experienced JavaScript developers.
Microsoft also stated that passing one MTA exam was sufficient to earn an MTA certification. That makes the exam different from a multi-exam professional certification path: the candidate’s objective was to demonstrate a foundational programming area through one exam. The credential was designed as an early signal of technical understanding, not as proof of advanced application architecture or production engineering.
The title matters when interpreting old records. A transcript or certificate may identify the achievement as MTA: Introduction to Programming Using JavaScript, while a search for “98-382” may return study pages, question banks, or old preparation material. Confirm the exact exam name and candidate identity before assuming that a record belongs to this exam.
Who was the intended candidate?
The strongest fit was a beginner who needed a structured introduction to programming concepts expressed through JavaScript. A student, career starter, or business professional building technical literacy could use the exam as an early milestone. It was not necessary to approach it as though it were an expert JavaScript developer assessment.
For a present-day learner, the audience description is still useful even though the exam is retired. It points toward the right learning level: start with syntax and program flow, then practise small working programs, and only afterward move to frameworks, tooling, and larger application design. That sequence is a recommendation for learning, not a surviving Microsoft exam requirement.
What skills should a historical 98-382 study plan cover?
The supplied Microsoft sources confirm the exam title and its entry-level MTA purpose, but they do not provide a current 98-382 skills outline, domain list, or percentage blueprint. It would be misleading to present an invented set of measured skills or attach unsupported weights to topics. Use the study areas below as a practical JavaScript foundation, not as an official exam blueprint.
A sensible reconstruction of the learning target begins with the ability to read and write small JavaScript programs. That includes recognizing values and variables, using operators, choosing conditional branches, repeating work with loops, organizing reusable logic with functions, and tracing how data changes as statements execute. These are preparation recommendations based on the exam’s introductory programming title, not claims about an official current scoring model.
Next, work with common data structures and simple program inputs. Practise strings, numbers, Boolean values, arrays, and objects; compare values deliberately; and select an appropriate structure for a small task. Write code that handles ordinary and unexpected input rather than copying a memorized pattern. The objective is transferable reasoning: explain why a statement produces a result, not merely recognize its appearance.
Finally, connect language features to a basic execution environment. A learner should be able to run a short script, inspect output, identify a syntax or logic problem, and make a controlled correction. Browser-based examples may be useful for learning, but do not assume that a particular browser, editor, delivery platform, language version, question count, duration, or test format remains available for 98-382 unless Microsoft explicitly documents it.
There are no blueprint percentages in the supplied official research. Consequently, this guide does not compare domain weights or label study time with unsupported percentages. If you are reviewing an archived syllabus or institutional course plan, treat that document as historical and verify its provenance rather than combining it with current Microsoft certification information.
How do you turn a topic into evidence of ability?
For every language feature, produce a small program and an explanation. For a conditional, write a decision with at least two outcomes and describe the values that reach each branch. For a loop, state its starting condition, stopping condition, and changing value. For a function, identify its inputs, output, and assumptions. This method exposes gaps that recognition-based quizzes often hide.
Keep a short error log. Record the original behavior, the smallest change that fixed it, and the rule you learned. Typical entries might involve a value with the wrong type, an off-by-one loop boundary, a variable used before the intended assignment, or a function that returns a different value from the one the caller expects. The log becomes a targeted review list rather than a collection of vague reminders.
How should you prepare if your goal is JavaScript rather than the retired credential?
Use a build-and-explain approach instead of searching for a replacement set of 98-382 questions. Begin with language fundamentals, practise each concept in isolation, combine concepts in small programs, and finish by debugging unfamiliar code. A current learning route should be selected from Microsoft’s live offerings or another authoritative provider after checking its present objectives; the supplied sources do not identify a direct replacement certification for JavaScript.
Start with a baseline exercise before studying. Write a small script that accepts or defines data, makes a decision, repeats an operation, and prints a result. Do not look up the solution while creating it. Mark every point where you cannot explain the behavior. This gives you a personal starting list and prevents comfortable topics from consuming the whole preparation period.
Build a progression of compact projects. A text classifier, unit converter, expense summary, validation routine, or command-line style menu can exercise variables, expressions, conditions, loops, arrays, objects, and functions without requiring a large framework. Keep each project small enough to inspect. Add one requirement at a time and test what changed.
Read code aloud or annotate it line by line. Ask what each variable contains, which branch executes, how many loop iterations occur, and what a function returns. When the output is surprising, form a hypothesis before changing the code. This develops the tracing skill that a beginner programming assessment is intended to encourage, while avoiding dependence on recalled question wording.
Use authoritative learning material for concepts and your own programs for practice. Microsoft’s supplied learning resources include a beginner programming series, but the listed series is Python for Beginners rather than a 98-382 JavaScript blueprint. It may help with general programming habits, yet it should not be represented as official JavaScript exam preparation or as a replacement for 98-382.
Which study materials deserve caution?
Archived exam pages can preserve useful terminology, but they may contain obsolete availability information. Third-party practice banks can contain errors, stale syntax, or material unrelated to the original assessment. Dumps are especially poor preparation because they replace reasoning with recall and may involve improperly obtained content. Use official retirement and credential pages to determine status, then use transparent instructional material and original exercises to learn.
Avoid any resource that promises a pass, claims access to live questions, or tells you that memorizing a fixed answer set is enough. There is no supplied official evidence supporting such promises. A better resource explains a concept, shows why an example works, and gives you enough variation to solve a new problem independently.
What is a practical study roadmap?
Because 98-382 is retired, the roadmap below is for two legitimate purposes: rebuilding the JavaScript foundation associated with its introductory subject, or preparing for a current path whose objectives you have independently verified. It is not a schedule for booking 98-382. Adjust the sequence to your existing programming experience and the requirements of the destination credential or course.
Stage one: establish the language foundation
Begin by learning how JavaScript represents values and executes statements. Write short examples using variables, literals, operators, comparisons, and Boolean expressions. Then explain the result without running the program. Run it afterward and investigate any difference between your prediction and the actual output.
Do not move on because a code sample looks familiar. Change an input, remove a statement, or replace a value with a different type. These small variations reveal whether you understand the rule or have memorized one example. Keep the code readable so that a mistake can be located rather than hidden inside a large project.
Stage two: control flow and reusable logic
Once basic expressions are comfortable, practise conditions, loops, and functions together. Write programs that select an outcome, process a collection, and delegate a repeated operation to a function. Draw a simple execution trace for one normal input and one boundary input, then compare the trace with the program’s output.
Pay particular attention to boundaries and return values. A loop that skips the first item, processes one item twice, or never reaches its stopping condition can appear correct with easy data. A function that prints a result instead of returning it may also seem to work until another part of the program needs that result. Test those cases deliberately.
Stage three: data handling and debugging
Practise choosing between simple values, arrays, and objects for a clearly stated task. Add validation and deliberate error cases. Then debug a program you did not write recently, beginning with an observed failure and narrowing the cause one assumption at a time. This stage turns isolated syntax knowledge into dependable programming behavior.
Use tests that include empty input, a single item, repeated values, a boundary value, and an invalid value where the program’s purpose makes that relevant. The exact cases will depend on your project. The point is to make your reasoning visible and to check that a change fixes the cause rather than merely hiding one symptom.
Stage four: choose the next credential or learning target
After the foundation work, compare your goals with currently offered Microsoft credentials or other recognized learning routes. Microsoft’s MTA retirement FAQ says fundamentals certifications can be a starting point for foundation understanding and a springboard to role-based training across areas such as Azure, AI, Data, Power Platform, Microsoft 365, and Dynamics. That is direction for choosing a path, not a claim that one specific replacement maps to JavaScript.
Read the live page for the candidate credential before committing. Confirm that it is available, that its skills match your intended role, and that its current requirements suit your experience. Because Microsoft reserves the right to retire exams and credentials, check the official retirement information again when you are ready to schedule.
Conclusion
Exam 98-382 is best treated as a retired record and a historical introduction to programming with JavaScript, not as an exam that a new candidate can schedule. Confirm whether your immediate need is transcript evidence, foundational programming practice, or a current credential. If you already passed, use the Certification Dashboard to locate your certificate, badge, or transcript. If you have not passed, reject dump-based promises, practise the underlying programming skills, and select a live path whose official requirements you have checked.
