98-379 Software Testing Fundamentals Exam Guide
Exam 98-379 validates foundational knowledge of software testing, including testing approaches, test creation, project management, defect handling, and automation. Microsoft identifies it as Software Testing Fundamentals and presents its six-part online course as preparation for the exam and as a component of the MTA: Software Testing Fundamentals certification. This guide helps candidates decide whether to start with concepts, practical test design, bug workflows, or automation—and how to sequence study without relying on exam dumps or unsupported exam claims.
What does exam 98-379 validate?
Exam 98-379 is Microsoft’s Software Testing Fundamentals exam. The official course frames the subject as a foundational understanding of software testing and covers test methodologies, software bugs, creating and managing software tests, and test automation.
That scope makes the exam relevant to candidates who need a structured introduction to software quality activities rather than a narrow tool-specific credential. It can serve people entering software testing, developers who need stronger testing discipline, students building an initial technology foundation, and project participants who must understand how tests and defects move through a delivery process.
Microsoft describes the exam as a key component of the MTA: Software Testing Fundamentals certification. The same Microsoft course is presented as preparation for exam 98-379, so the course outline is the most useful official organizing framework available in the supplied research.
Who should consider this exam?
Choose this preparation path if you need to explain testing fundamentals, distinguish broad delivery approaches, create appropriately scoped tests, work with defects, or understand the role of automation. It is especially suitable when your current knowledge is uneven across these areas.
A candidate with testing experience should not assume that practical exposure covers every assessed concept. Use the outline as a gap-checking tool. A tester may know how to log bugs but need to revisit application lifecycle management, testing methodologies, or automation strategy. A developer may understand code-level testing but need more practice with user-centric testing, test plans, milestones, reports, and defect management.
What the supplied evidence does not establish
The supplied official research does not provide an exam blueprint with domain percentages, question count, passing score, exam duration, price, languages, prerequisites, delivery method, or current availability. Do not treat third-party listings or practice claims as confirmation of those details.
Before scheduling, confirm current registration, delivery, policy, and status information through Microsoft’s current certification and exam pages. This guide uses only the supplied Microsoft Learn evidence for the exam’s subject coverage.
How is the official learning content organized?
Microsoft lists six episodes in the Software Testing Fundamentals course series. The sequence moves from basic concepts to methodologies, test creation, project management, bugs, and automation. Studying in that order is a sensible default because later topics depend on vocabulary and decisions introduced earlier.
The first episode covers testing fundamentals, fundamentals of programming, and application lifecycle management. The second addresses Waterfall and Agile testing methodologies and related techniques. The third focuses on creating software tests; the fourth covers management of testing projects; the fifth deals with bugs; and the sixth introduces test automation.
The episodes are dated March 3–4, 2014 in Microsoft’s series information. That date describes the course episodes, not a current exam schedule or a guarantee that every exam detail remains unchanged. Use the concepts as a learning structure and verify time-sensitive exam information separately.
Module 1: Testing fundamentals
Begin with the vocabulary that lets you reason about a test rather than merely execute one. Microsoft’s first episode includes software testing, fundamentals of programming, and application lifecycle management. Your notes should connect the purpose of testing with the stages and work involved in developing an application.
A practical study exercise is to take a small feature, such as account sign-in, and describe where testing-related decisions arise during its lifecycle. Identify what must be understood about the feature, what evidence a test should produce, and how a defect would affect later work. Keep the focus on reasoning, not on memorizing a list of tool commands.
Module 2: Testing methodologies
The second episode explores the fundamentals of Waterfall and Agile testing methodologies and aligned testing techniques. Study the relationship between a development approach and the way testing is planned, performed, reported, and repeated.
Do not reduce this topic to a superficial comparison of two labels. Build a table in your own notes with the planning rhythm, communication needs, test timing, and feedback patterns associated with each approach. Then apply the table to a feature change and explain how the testing workflow would need to adapt. This exercise prepares you to evaluate scenarios instead of reciting definitions.
Module 3: Creating software tests
Microsoft’s third episode covers user-centric testing, software testability, test-plan components, feature testing, and appropriately scoped test cases. This is the point where foundational terms become test-design decisions.
Practice turning a feature description into a compact test plan. State the user goal, identify the behavior to verify, define the relevant setup and expected result, and limit each case to a clear purpose. Add boundary or unusual conditions only when they reveal a meaningful risk. A test case that tries to prove everything at once is difficult to interpret when it fails.
The official episode explicitly connects test creation with methodologies and techniques from the testing-methodologies module. Revisit the second episode before finalizing your test examples so that your plan reflects the delivery approach rather than treating test design as isolated paperwork.
Module 4: Managing software test projects
The fourth episode covers testing milestones, the Agile process, distributed teams, and test reports. Preparation should therefore extend beyond writing test cases to include coordination, visibility, and communication.
Create a simple project scenario and identify the testing milestones that matter before, during, and after a release activity. Decide what information a report must communicate to someone who will not perform the test personally. Include progress, findings, and unresolved concerns in your practice notes, but do not invent an official report format that Microsoft has not supplied.
The episode also addresses distributed teams. Think through how a test result, reproduction detail, or decision could be misunderstood when team members are working apart. A useful preparation habit is to rewrite vague statements such as “the feature is broken” into observable information: the condition, action, result, and evidence needed for follow-up.
Module 5: Working with bugs
The fifth episode covers detecting software defects, logging bugs, and managing bugs. Treat this module as a workflow: identify a defect, record information that enables investigation, and manage the issue as the project decides what happens next.
For practice, write bug records from short feature scenarios. Include a precise summary, reproducible steps, expected behavior, observed behavior, and supporting context. Then review each record for ambiguity. Could another team member understand what to do without asking you to restate the entire situation? If not, improve the record.
Avoid confusing a failed expectation with a complete diagnosis. A tester may be able to demonstrate a defect without knowing its code-level cause. Your notes should distinguish what was observed from what is suspected. That distinction produces clearer communication and reduces the risk of presenting an unverified explanation as fact.
Module 6: Automating software tests
The sixth episode covers test automation, automation strategies, writing automation tests, and managing test scripts. Study automation as a set of design and maintenance choices, not as a promise that every test should be automated.
Make a comparison sheet for manual and automated execution using practical criteria: repeatability, setup effort, maintenance, feedback speed, and the kind of judgment required. Then choose a small, stable scenario and outline what an automation test would need to arrange, perform, verify, and report. Keep the exercise conceptual unless you already have an appropriate development environment.
Managing test scripts is part of the official module, so include maintenance in your reasoning. An automated check that is hard to understand or update can create noise rather than useful feedback. When reviewing an example, ask whether the script expresses the intended behavior clearly and whether a future change could make its result misleading.
What should you study first?
Start with the official six-episode structure, then adjust the order after a short diagnostic. Candidates with no testing background should follow the sequence from fundamentals through automation. Candidates with work experience can begin with the area they find weakest, but should still return to the earlier modules before attempting a final review.
Use a three-pass method. In the first pass, watch or read for terminology and write a one-sentence explanation of each topic. In the second, apply every topic to one consistent sample application. In the third, explain the choices without looking at your notes and identify where your reasoning remains vague.
The supplied Microsoft Learn training site also offers self-directed learning paths and modules, with options to learn at an individual pace or from an instructor. Use those resources to reinforce a concept when the course episode gives you a starting point but not enough practice.
A useful diagnostic before deep study
Without using leaked questions or exam dumps, rate your confidence in each of the six modules as strong, developing, or unfamiliar. Then prove the rating with a task rather than relying on familiarity with the headings.
For testing fundamentals, explain the role of testing and connect it to programming and application lifecycle management. For methodologies, contrast how testing work fits Waterfall and Agile contexts. For test creation, produce a scoped case from a feature description. For project management, outline milestones and a useful report. For bugs, write a reproducible defect record. For automation, describe a strategy and the lifecycle of a test script.
The module where you cannot produce a clear artifact is your first study priority. This approach is more reliable than spending equal time on every topic or repeatedly rereading material you already understand.
How to take notes that help with scenarios
Organize notes around decisions and evidence. For each concept, record what problem it addresses, what information a tester needs, what action follows, and what mistake the concept helps prevent.
For example, a note about appropriately scoped test cases should not stop at a definition. Add a before-and-after example showing how a broad case can be divided into cases with clearer purposes. A note about bug management should distinguish detection, logging, and subsequent handling because Microsoft presents those as related but separate parts of the bugs module.
Use your own wording, but preserve the official topic labels in a separate index. This gives you two benefits: you can retrieve the Microsoft terminology when reviewing the course, and you can explain the idea in language that demonstrates understanding rather than memorization.
How can you turn the course into practical preparation?
Use one small fictional product throughout your study, such as a web application with sign-in, profile editing, and a search feature. The product is only a practice device; it does not represent an official exam scenario. Reusing it lets you compare methodologies, design tests, log defects, plan milestones, and consider automation without learning a new context each time.
Begin by writing a short feature description and a user goal. From there, create a test plan outline, several focused test cases, a sample defect, a project report, and an automation outline. At each stage, state what information supports your decision and what remains uncertain.
This method produces review material you can interrogate. If you cannot explain why a case is in scope, why a defect is reproducible, or why a check is a candidate for automation, return to the relevant episode instead of adding more pages of notes.
Exercise: design a focused test set
Choose one feature and list its normal user flow before adding unusual conditions. Separate the user’s intended outcome from implementation details. Then create cases that each answer a specific verification question.
Review the set for missing perspectives. Is the behavior understandable from the user’s point of view? Is the feature testable with the information available? Does each case have an expected result that can be evaluated? Are the cases small enough that a failure points toward a useful investigation? These questions directly reinforce the third episode’s emphasis on user-centric testing, testability, test-plan components, feature testing, and appropriately scoped cases.
Exercise: write and review a bug record
Take one deliberately failed test from your practice feature and record it as a defect. Write the summary so that it identifies the affected behavior without overstating the cause. Include the conditions required to reproduce the issue, the actual result, and the expected result.
Now ask whether the record would allow another person to confirm the issue. Remove assumptions that are not supported by observation. Finally, describe what information a project report might need to communicate about the defect. This links the fifth episode’s defect workflow with the fourth episode’s focus on test reports and project management.
Exercise: make an automation decision
Select a repeatable check from your test set and explain why automation might help. Then identify the work automation would add: creating the test, maintaining its script, interpreting failures, and keeping its result meaningful as the application changes.
Do not assume that automation is automatically superior. The official sixth episode covers strategies, writing automation tests, and managing scripts, so your decision should address the complete lifecycle. A strong study answer explains both the likely benefit and the maintenance responsibility.
What mistakes commonly weaken preparation?
The most damaging mistake is studying only vocabulary. Software testing fundamentals are easier to retain when each term is attached to an action: selecting a method, creating a plan, scoping a case, reporting progress, logging a defect, or maintaining an automated check.
A second mistake is treating the six episodes as unrelated videos. The official outline is cumulative. Methodologies inform test creation; project management gives testing milestones and reports a context; bug handling turns test findings into managed work; automation depends on knowing what should be tested and how its result will be evaluated.
A third mistake is preparing from claims that the supplied evidence does not support. Do not build a schedule around an unverified question count, score, duration, price, language, or delivery format. Confirm those details through Microsoft before making a registration decision.
Mistake: memorizing dumps or alleged live questions
Exam dumps and leaked-question claims are not a substitute for understanding and may be inaccurate, unauthorized, or outdated. They also encourage recall of isolated wording instead of the reasoning needed to create tests, interpret defects, and choose an appropriate testing approach.
Use original practice scenarios instead. Write your own question prompts from the official topics, answer them without notes, and explain why an alternative would be weaker. This creates legitimate recall practice without implying access to live exam content or promising a result.
Mistake: confusing test execution with testing knowledge
Running a check is only one part of the work represented in the course. The official modules also address planning, methodology, project management, reports, bugs, and automation strategy.
When reviewing a feature, ask what should be tested, why it matters, how the case is scoped, how the result is communicated, and what happens when the expected behavior is not observed. This broader sequence exposes gaps that repeated execution alone will not reveal.
Mistake: automating before defining the behavior
An automated script cannot compensate for an unclear test objective. If the expected result is vague, the script may produce a technically precise but practically unhelpful outcome.
Define the user behavior and acceptance evidence first. Then consider whether the check is stable, repeatable, and maintainable enough to automate. Keep the reasoning aligned with the sixth episode’s coverage of strategies, writing automation tests, and managing test scripts.
What is a practical study roadmap?
A flexible roadmap should move from understanding to application and then retrieval. Do not assign an official exam date or fixed study duration unless Microsoft confirms the current scheduling information; instead, use checkpoints that tell you whether to proceed or revisit a topic.
At the first checkpoint, you should be able to summarize the purpose of each module. At the second, you should have created a connected set of practice artifacts. At the final checkpoint, you should be able to explain decisions without copying notes and identify the evidence behind each answer.
The roadmap below is a preparation recommendation, not an official Microsoft schedule.
Stage 1: establish the foundation
Study the first episode and create a glossary for testing, programming fundamentals, and application lifecycle management. Do not move on merely because the terms look familiar. Explain each term in your own words and connect it to the sample application.
Next, study the second episode. Build a Waterfall-and-Agile comparison based on testing activities and techniques, not slogans. Write one scenario in which the testing workflow must adapt to the chosen methodology. If you cannot explain the adaptation, review the episode and revise the scenario.
Stage 2: create evidence of understanding
Study the third episode and produce a test-plan outline, a feature-focused test set, and appropriately scoped cases for your sample application. Review each case for user relevance, testability, clear expected results, and a manageable purpose.
Then study the fourth episode and connect the cases to a project view. Identify testing milestones, describe how an Agile process might affect coordination, consider the needs of distributed teams, and draft a report that communicates meaningful status and findings. The goal is not to imitate an official form; it is to practice selecting useful information.
Stage 3: manage findings and automation
Use the fifth episode to turn one failed case into a clear defect record. Separate observation from diagnosis, then outline how the issue would be managed within the project context.
Use the sixth episode to review test automation, strategies, writing automation tests, and managing test scripts. Select one practice case for an automation outline and explain the maintenance implications. Compare that outline with a case that requires more judgment or changes frequently, and defend your choice rather than applying automation indiscriminately.
Stage 4: retrieve, correct, and verify
Close your preparation with closed-book recall. For each module, write a short explanation, one example, one common mistake, and one decision a tester must make. Compare your response with the official episode topics and mark omissions.
Return only to weak areas. Rework the associated practice artifact instead of passively replaying all content. Finally, check Microsoft’s current official information for registration and exam logistics before scheduling. The supplied research does not establish those time-sensitive details.
How should you use Microsoft Learn resources?
Use the Software Testing Fundamentals series as the primary subject map because Microsoft explicitly presents it as preparation for exam 98-379. Use Microsoft Learn training as a supplementary place to find self-directed modules, learning paths, or instructor-led options when you need additional practice or a different explanation.
The series page identifies the complete six-module outline and links the individual episodes. Open the relevant episode when a study artifact exposes a gap rather than browsing randomly. The episode pages provide the topic focus and, where supplied, section markers that can help you return to a specific concept.
Microsoft Learn training describes learning paths and modules as ways to explore a topic in depth or accomplish a specific task. That format is useful after the fundamentals course: choose a resource that addresses the exact weakness you identified, then test yourself by applying the idea to your sample feature.
A source-led review routine
Read the series page first to establish the six-module map. Use episode 01 for testing fundamentals, programming fundamentals, and application lifecycle management; episode 02 for Waterfall, Agile, and related techniques; episode 03 for test creation; episode 04 for test project management; episode 05 for bugs; and episode 06 for automation.
After each episode, create one artifact and one explanation. The artifact proves that you can use the concept; the explanation proves that you can communicate it. Keep both short enough to review repeatedly, but specific enough to expose missing reasoning.
What should you do before scheduling?
Before scheduling exam 98-379, confirm that the current Microsoft information still matches your goal and that the exam is available through the official route. The supplied research identifies the exam and its learning content but does not verify current scheduling, delivery, pricing, score, or status details.
Review the six modules once more and identify any area where you can recognize a term but cannot apply it. Give priority to that gap. Then prepare the practical information you would need for registration from Microsoft’s current exam pages rather than relying on an old course page or an unofficial listing.
If your goal is broader than software testing fundamentals, also check whether the certification path still fits your career plan. Microsoft describes 98-379 as a component of the MTA: Software Testing Fundamentals certification in the supplied source, but current credential structures can be time-sensitive and should be confirmed directly.
A final readiness checklist
You are better prepared when you can explain the purpose of software testing and relate it to programming and application lifecycle management; distinguish the testing implications of Waterfall and Agile; create a test plan and appropriately scoped feature cases; describe milestones, distributed-team considerations, and test reports; detect, log, and manage bugs; and explain automation strategies, test writing, and script management.
This checklist is based on the official course topics, not a claim about the exact exam blueprint or question format. If one item remains a definition without an example, turn it into a practice scenario before scheduling.
How to use this guide responsibly
Use this page to choose a study sequence and identify practice work, not as a replacement for current Microsoft registration information. The official course provides a strong subject structure, while the candidate must still verify any time-sensitive exam detail before making a booking decision.
Most importantly, prepare to reason about testing work. Read the official material, create your own cases and defect records, review the consequences of your choices, and use supplementary Microsoft Learn content when a concept needs reinforcement. Avoid dumps, alleged live questions, and unsupported promises; they do not establish legitimate readiness.
Your next action
Open the Microsoft Software Testing Fundamentals series, review the six-module outline, and begin with the module that your diagnostic shows is weakest. Create one concrete artifact before moving on: a glossary for fundamentals, a methodology comparison, a test plan, a project report, a bug record, or an automation outline. After completing the sequence, verify current exam information directly with Microsoft and make your scheduling decision from that official information.
Conclusion
Exam 98-379 preparation is most effective when you connect the official six-module course to deliberate practice. Learn the fundamentals, compare methodologies, design focused tests, manage project information, handle defects, and evaluate automation as a maintained system. The supplied evidence supports that learning scope, but not current exam logistics or blueprint details. Use Microsoft’s current information for scheduling, and use your own scenario-based work to decide whether your knowledge is ready.
