98-379 Software Testing Fundamentals Exam Guide
Exam 98-379, Software Testing Fundamentals, is intended to establish a foundation across testing concepts, methodologies, test creation, project management, defect handling, and automation. Microsoft presents its Software Testing Fundamentals course as preparation for this exam and identifies the exam as a component of the MTA: Software Testing Fundamentals certification. This guide helps you decide whether the exam matches your current role, how to organize the official learning content, and what to verify before scheduling because the supplied Microsoft material does not establish current delivery, scoring, or registration details.
What does exam 98-379 cover?
Exam 98-379 is centered on foundational software-testing knowledge rather than one narrow tool or programming language. The official Microsoft course groups preparation into testing fundamentals, testing methodologies, creating software tests, managing test projects, working with bugs, and automating software tests.
Microsoft identifies the exam as “Software Testing Fundamentals” and presents the related online course as preparation for exam 98-379. The course is also described as a key component of the MTA: Software Testing Fundamentals certification. Those statements establish the exam’s subject and certification context, but they do not provide a current exam blueprint, question count, passing score, or delivery policy.
The six preparation areas
The official course series lists six areas: testing fundamentals; testing methodologies; creating software tests; managing software test projects; working with bugs; and automating software tests. Treat these as a connected learning sequence, not six unrelated video topics.
The sequence moves from terminology and development context to the construction and management of tests, then to defect workflows and automation. That progression makes it useful for a candidate who needs a structured starting point, especially when prior experience is uneven across manual testing, project coordination, and automation.
What the available evidence does not confirm
The supplied official sources do not state exam domain percentages, question formats, duration, score requirements, languages, prerequisites, registration options, price, or current availability. Do not use an unofficial page or a practice product to fill those gaps as though it were a Microsoft requirement.
Before committing to a date, check Microsoft’s current certification and exam information through the official Microsoft Learn and certification channels. The course pages supplied here are useful for content preparation, but they should not be treated as a complete scheduling or policy page.
Who is 98-379 for?
This exam is a reasonable subject match for learners building a first formal testing foundation, people moving into a software quality role, and practitioners who need a common vocabulary for tests, defects, lifecycle work, and automation. It can also serve as a structured review for developers or project participants who contribute to testing.
The available evidence does not define a mandatory candidate profile or prerequisite. Use your actual work as a readiness indicator: if you can explain why a test is needed, design a scoped case, describe a defect clearly, and discuss when automation helps, you have a practical base for studying the official topics.
Choose the exam when your gap is breadth
Choose this preparation path when you need broad testing fundamentals rather than a credential focused on a particular testing platform. The course includes methodologies, test design, project management, bugs, and automation, so it is better suited to foundational breadth than to deep specialization in one automation framework.
If your immediate goal is a tool-specific credential, compare its current objectives with the scope of 98-379 before scheduling. The Microsoft material supplied for this guide does not claim that the exam certifies advanced expertise in a particular programming language, test framework, or product.
Use experience to identify weak areas
A manual tester may need extra work on programming fundamentals and automation. A developer may understand code but need deliberate practice with test planning, user-centric testing, defect management, and reporting. A project coordinator may know milestones and reports but need hands-on practice creating appropriately scoped test cases.
Make a simple three-column inventory: “can explain,” “can apply,” and “need to study.” Place each of the six course areas in the inventory, then add one concrete artifact or explanation beside it. This prevents familiarity with terminology from being mistaken for usable understanding.
How should you study the official course?
Study the six Microsoft episodes in order, but turn each topic into an output rather than passively watching it. After each episode, write a short explanation, create a small testing artifact, and record the decisions that artifact demonstrates. This approach exposes gaps that rereading definitions can hide.
Microsoft Learn also provides self-directed modules and learning paths, with study intended to fit different schedules. Use those resources to reinforce concepts, but keep the exam’s supplied Software Testing Fundamentals series as the organizing spine because it directly names the exam and its six preparation areas.
Start with fundamentals, programming, and lifecycle context
The first episode covers testing fundamentals, fundamentals of programming, and application lifecycle management. Begin by defining the purpose of software testing in your own words, then connect testing work to the lifecycle rather than treating it as an isolated final step.
Your study output can be a one-page lifecycle sketch showing where test planning, execution, defect reporting, and retesting fit. Add a small glossary for terms you confuse. The goal is not to memorize a list; it is to explain how testing decisions relate to software development work.
Compare Waterfall and Agile deliberately
The second episode covers Waterfall and Agile testing methodologies and related testing techniques. Prepare a comparison that focuses on how planning, feedback, test timing, and communication differ between the approaches. Avoid reducing the distinction to a slogan such as “one is sequential and one is iterative.”
For each methodology, write a short project scenario and identify when a test plan is shaped, when feedback is returned, and how a change may affect testing. Then explain which assumptions in the scenario would need confirmation. This builds the reasoning needed to apply methodology concepts rather than recite labels.
Build a test plan and scoped cases
The third episode covers user-centric testing, software testability, test-plan components, feature testing, and appropriately scoped test cases. Use one ordinary feature, such as account sign-in or a search filter, and create a small test plan around its user goal.
Include the feature’s intended behavior, relevant conditions, test data, expected results, and boundaries. Keep each case narrow enough that a failure points toward a specific behavior. Review every case by asking whether it tests a user-relevant risk and whether another tester could understand the expected result without guessing.
Practice project management and reporting
The fourth episode covers testing milestones, the Agile process, distributed teams, and test reports. Study this area by treating test work as a project with dependencies and communication needs, not simply as a collection of executed cases.
Create a lightweight milestone plan for a fictional release. Add entry or completion conditions only where you can explain their purpose, note a dependency that could delay testing, and draft a report that distinguishes completed work, outstanding risk, defects, and next action. Keep the report factual and decision-oriented.
Use a disciplined defect workflow
The fifth episode covers detecting software defects, logging bugs, and managing bugs. A strong preparation exercise is to convert an observed failure into a report that another person can reproduce and triage.
Write a concise title, environment or context, reproduction steps, expected result, actual result, and supporting evidence where available. Then add a proposed next action without pretending that the tester alone decides final priority or resolution. Review whether the report separates observation from interpretation; that distinction prevents avoidable confusion.
Understand automation as a managed testing activity
The sixth episode covers test automation, automation strategies, writing automation tests, and managing test scripts. Prepare for this topic by evaluating what should be automated, what should remain manual, and how scripts remain trustworthy over time.
Take a small group of manual cases and classify them by repeatability, stability, maintenance cost, and value of rapid feedback. Draft the logic for one automation test without relying on a specific tool. Then list how a script could become unreliable, such as a changed interface, unstable data, or an assertion that does not verify the intended behavior.
What practical skills should your notes demonstrate?
Your notes should show decisions and relationships, not only definitions. You should be able to move from a user need to a test plan, from a failed result to a useful bug report, and from repeated testing work to a reasoned automation choice. These are practical applications of the topics Microsoft names in the course.
Use explanation as your test of understanding. If you cannot explain why a case is appropriately scoped, why a defect report is actionable, or why a script should be maintained, return to the relevant episode and revise the artifact rather than simply highlighting more text.
Test design: connect risk, behavior, and evidence
A test case is stronger when its expected result is observable and its scope is clear. Start with the user-facing behavior, identify a meaningful condition or input, and specify what evidence would show success or failure.
For a feature with several rules, split the rules into cases instead of hiding them in one long scenario. Record assumptions separately from expected behavior. This makes later review easier and helps distinguish an unclear requirement from a failed implementation.
Defect management: preserve the chain of reasoning
A useful defect record preserves the chain from action to observed result. It should allow a developer, tester, or manager to understand what happened, what should have happened, and what decision is needed next.
Do not turn every unexpected result into a conclusively diagnosed cause. Report what you observed, include reproducible conditions, and identify uncertainty. During study, ask a colleague or reviewer to reproduce your report using only its contents; missing information becomes immediately visible.
Automation: judge value, not novelty
Automation is valuable when it produces dependable feedback at an acceptable maintenance cost. The official automation episode includes strategies, writing automation tests, and managing test scripts, so preparation should include the lifecycle of an automated test, not merely the act of writing code.
Avoid the mistake of treating automation as a replacement for all human testing. A sensible decision considers repeatability, feedback speed, data control, stability, and the cost of maintaining the script. Keep a record of the reason for automating each case and the behavior the script actually verifies.
A practical study roadmap
A useful roadmap has four passes: establish the subject map, create representative artifacts, review weak areas, and verify administrative details. The official series supplies the subject map; your outputs supply application practice. Do not set a test date until you have checked current Microsoft information for registration and exam conditions.
The roadmap can be compressed or extended according to your background. Microsoft Learn describes training that can be used in short or longer study sessions, so schedule by available focus time rather than adopting an unsupported fixed duration.
Pass one: map the six areas
Watch or study the six official episodes in sequence and produce a one-page summary for each. Capture the central vocabulary, the decisions a tester makes, and one question you still cannot answer. At this stage, resist the temptation to spend all your time on the topic you already know best.
At the end of the pass, mark each area as strong, familiar, or uncertain. “Familiar” means you recognize the terms; “strong” means you can explain and apply them. Schedule the next pass around uncertain areas, while still preserving time for integrated practice.
Pass two: create a connected case study
Use one fictional product or feature throughout your exercises. Begin with a user goal, compare how its testing might fit different methodologies, create a scoped plan and cases, organize milestones, log a defect, and select a small automation candidate.
A connected case study reveals handoffs between topics. For example, a poorly scoped case can create an ambiguous defect, while an unstable automated script can undermine a report. Record each handoff and explain what information must survive it.
Pass three: review by retrieval
Close your notes and answer questions from memory: What belongs in a test plan? How do Waterfall and Agile affect testing work? What makes a bug report actionable? How do you select and maintain automation? Explain each answer in plain language before checking the source.
When an answer is incomplete, update the artifact that exposed the gap. A failed explanation about test reports should lead to a revised report, not just another copied definition. This keeps revision tied to a visible weakness.
Pass four: confirm readiness and logistics
Before scheduling, verify the current official exam page, certification status, registration route, delivery choices, language information, prerequisites, and policy requirements. None of those details is established by the supplied course pages, and time-sensitive information should come from the current official source.
For content readiness, review your six summaries and connected case study. You should be able to explain every artifact, identify its assumptions, and state what you would investigate when the available evidence is incomplete. If one area remains only memorized, postpone scheduling and practice its application.
Common preparation mistakes to avoid
The most damaging mistakes are usually study-process mistakes: relying on a topic list without applying it, treating course familiarity as exam readiness, and overlooking the management and defect areas because automation appears more technical. Correct those habits by producing and reviewing test artifacts.
Do not use leaked questions, exam dumps, or memorization claims as a substitute for learning. They are not evidence of current exam coverage, do not establish official requirements, and cannot replace the ability to reason about testing situations.
Mistake: studying automation before foundations
Automation is easier to understand when you can first define the behavior being tested, the expected result, and the evidence needed. Starting with scripts can produce tests that execute successfully without checking the right behavior.
Study fundamentals, methodology, and test creation first. Then use automation to revisit selected cases. This order makes the script serve a testing objective instead of becoming the objective itself.
Mistake: writing broad, untestable cases
A case that tries to validate an entire feature, workflow, and reporting path at once is difficult to diagnose. Broad wording also makes expected results subjective and weakens later defect logging.
Split the case by meaningful behavior and state observable results. If a requirement is ambiguous, record the ambiguity as a question or risk instead of disguising it as a test condition.
Mistake: confusing a defect with a diagnosis
A tester can often establish that actual behavior differs from expected behavior without knowing the underlying cause. Claiming a cause too early can misdirect investigation and make the report less useful.
Separate observed facts, reproduction information, and hypotheses. This practice aligns naturally with the official focus on detecting, logging, and managing bugs.
Mistake: ignoring communication work
Testing projects require milestones, reports, and coordination, including when teams are distributed. A candidate who studies only execution steps may miss how test information supports release decisions.
Practice writing a short status report that names completed work, known defects, unresolved risk, and the next decision. Avoid vague status language that cannot tell a reader what action is required.
Mistake: assuming old course pages prove current exam policy
The supplied Microsoft course pages are dated course material and describe subject coverage. They do not, by themselves, prove that current registration, delivery, scoring, or certification policies remain unchanged.
Use the course for conceptual study and confirm time-sensitive administrative information separately through Microsoft’s current official channels. Keep screenshots or notes of the policy page you relied on when making a scheduling decision.
How to use Microsoft Learn efficiently
Microsoft Learn supports self-directed modules and learning paths, allowing candidates to study on their own schedule. Use it to fill conceptual gaps and organize follow-up learning, while keeping a written connection between each resource and one of the six Software Testing Fundamentals areas.
Short sessions work well for retrieval, vocabulary review, and defect-report editing; longer sessions are better for building a connected case study. End every session with a visible output or unanswered question so the next session begins with a specific task.
A focused session pattern
Start by stating one objective, such as “write appropriately scoped cases for one feature.” Study the relevant Microsoft material, close it, and recreate the idea from memory. Finish by comparing your work with the source and noting one correction.
This pattern prevents passive video consumption. It also gives you a growing portfolio of private study artifacts: summaries, methodology comparisons, test plans, cases, bug reports, milestone plans, reports, and automation decisions.
When to use additional learning
Use additional Microsoft Learn modules or paths when the official episode exposes a knowledge gap in programming, lifecycle concepts, or testing practice. Select material that addresses the gap directly instead of collecting unrelated courses.
Do not assume that every Microsoft Learn item is an exam objective. Map each added resource to a stated course area and stop when it has answered the question you identified. This keeps preparation focused and reduces resource overload.
What should you do before booking?
First, confirm that the exam’s testing-fundamentals scope matches your goal. Next, complete the six-area self-assessment and build at least one connected set of study artifacts. Finally, verify current official scheduling and policy information rather than relying on catalogue pages or old course metadata.
If your content readiness is acceptable but administrative information is unclear, resolve the administrative question before paying or selecting a date. If your logistics are clear but your artifacts reveal weak fundamentals, continue studying before booking. Separating those decisions reduces avoidable rescheduling and anxiety.
A final readiness checklist
You are better positioned to schedule when you can explain the purpose of testing and its lifecycle context, compare Waterfall and Agile testing, create a focused plan and test case, describe milestones and reports, write an actionable bug record, and reason about automation strategies and script maintenance.
Also confirm that you know where to check current exam policies. The supplied evidence does not establish a passing score, exam duration, format, or delivery method, so leave those items as official-source verification tasks rather than assumptions in your plan.
Your next three actions
Open the Microsoft Software Testing Fundamentals series and create a six-row study tracker. Complete the first row by summarizing testing fundamentals, programming fundamentals, and application lifecycle management. Then choose one feature and begin a test plan that you will expand through the remaining areas.
After each study session, mark whether you can explain, apply, or still need help with the topic. When all six rows contain an applied artifact, check Microsoft’s current exam information and make the scheduling decision using verified administrative details.
Conclusion
Exam 98-379 preparation is best treated as a progression from testing vocabulary to applied judgment. Use Microsoft’s six-part course to structure study, create artifacts that demonstrate test planning and defect reasoning, and include project management and automation rather than focusing only on test execution. The official material supplied here does not confirm current delivery or scoring details, so verify those items before scheduling. A clear scope check, evidence-based study tracker, and final policy review will give you a more reliable next step than memorization alone.
