98-372 Microsoft .NET Fundamentals: Exam Scope, Retirement Status, and a Practical Study Plan
Exam 98-372, Microsoft .NET Fundamentals, was designed to validate foundational knowledge of the .NET Framework and related development concepts. It served beginners, especially students in high schools and two-year colleges, who wanted an entry point into software development rather than a credential requiring substantial job experience. The most important decision for a reader today is whether to study its historical objectives for foundational learning or pursue a current Microsoft credential, because the MTA exam program has retired and 98-372 is no longer a normal scheduling target.
What did Exam 98-372 validate?
98-372 validated introductory knowledge of Microsoft .NET fundamentals, including how .NET organizes namespaces, classes, libraries, managed code, memory, application settings, events, delegates, and exceptions. It was not positioned as an advanced developer assessment; its purpose was to confirm that a learner understood the building blocks needed for further software-development study.
Microsoft titled the exam “Microsoft .NET Fundamentals.” In Microsoft’s MTA developer materials, Exam 372 was also described under the name “Microsoft .NET Development Fundamentals.” The target candidate was seeking to prove knowledge and skills in Microsoft .NET fundamentals, making the exam most relevant as an entry-level knowledge checkpoint rather than evidence of broad professional development experience.
The credential’s place in the MTA program
Exam 98-372 belonged to Microsoft Technology Associate, or MTA, an entry-level certification suite. Microsoft described the developer track as a starting point for people intending to build a career as software developers. Other MTA developer subjects included software development, web development, gaming, HTML5 app development, software testing, mobility, and cloud fundamentals.
The MTA program was targeted primarily at students in high schools or two-year colleges. It was designed as an entry point to a future technology career and did not assume on-the-job experience. That context matters when interpreting the objectives: the exam expected a learner to understand core ideas and terminology, not to demonstrate the depth expected from a specialist developer.
Is 98-372 still available to schedule?
No. Microsoft retired the MTA certification program and exams on June 30, 2022. Microsoft stated that MTA exams could not be retaken after that date, and the official retirement guidance says candidates cannot take a retired exam or earn its associated certification after the retirement date. Treat any page suggesting that a new 98-372 appointment is routinely available as outdated until the official Microsoft or Certiport channels say otherwise.
This changes the preparation decision completely. Do not purchase an alleged 98-372 exam voucher, reserve study time around an unverified appointment, or rely on a third-party claim that the exam has returned. If your objective is to learn older .NET concepts, the historical objectives can still structure study. If your objective is a current Microsoft credential, begin with Microsoft Learn’s current certification and training catalog instead.
What happened to credentials already earned?
Microsoft says an MTA certification already earned remains on the certification transcript and remains printable after retirement. The retirement FAQ also states that such certifications move to the “Certification History” section of the transcript two years after the certifications retire. Retirement therefore affects new testing and earning the credential, not the continued record of a certification that was already earned.
Do not confuse retained transcript history with current certification availability. A historical 98-372 result can document what a candidate passed, but it should not be presented as a current exam option or as proof of current .NET platform expertise. When reviewing a résumé or academic record, label the credential accurately and pair it with recent development work or training.
Should you study this exam at all?
Study the 98-372 objectives when you need a structured introduction to legacy .NET concepts, are reviewing an older transcript, or are using the blueprint to identify gaps before moving to current developer training. Do not treat preparation for this retired exam as a direct route to earning a new Microsoft certification.
A useful rule is simple: learn the concepts, not the retired test. Build small exercises, explain the behavior of the code, and then transfer the knowledge into a current learning path. This approach preserves the educational value of the objectives without implying that memorizing old exam material can produce a current credential.
Who was the intended candidate?
The intended candidate was a beginner or early-stage developer who wanted to demonstrate foundational .NET knowledge. Candidates were expected to have some experience with a .NET language such as C# or Microsoft Visual Basic .NET, but the MTA program did not assume professional, on-the-job experience. That makes basic programming fluency a sensible starting checkpoint.
Before studying the blueprint, test your starting point with a small program in a .NET language. You should be able to read a class definition, identify a method and property, follow a conditional branch, and explain what happens when an error is raised. If those actions are unfamiliar, begin with language fundamentals before attempting .NET-specific terminology.
A sensible readiness check
Use a short diagnostic rather than guessing from the exam title. Create or inspect a small application and identify its namespaces, classes, event handlers, configuration settings, and exception-handling path. Then describe where an object is created, how it is referenced, and what happens when the reference is no longer needed.
This is a preparation recommendation, not an official pass requirement. The official guide’s expectation of experience with C# or Visual Basic .NET supports treating language familiarity as a prerequisite for efficient study, but it does not establish a required employment history, formal course, or specific amount of experience.
Which skills belong in your study plan?
Organize preparation by concept clusters rather than by isolated vocabulary. The supplied official objectives identify .NET organization and object-oriented structure, application settings, events and delegates, structured exception handling, and the underlying managed-code and memory concepts. A study plan should connect each term to a code example or explanation so that recognition becomes usable understanding.
The supplied research does not include blueprint percentages or a complete weighted domain table. Do not assign invented percentages to the objective areas, and do not compare bare percentages. Give each topic enough attention to explain its behavior, distinguish related terms, and apply it in a small .NET example.
Namespaces, classes, and class libraries
Start with the organizational model. Review how namespaces group related types, how classes define behavior and state, how class hierarchies express relationships, and how class libraries provide reusable functionality. The objective coverage included .NET class hierarchies, object-oriented concepts, namespaces, and class libraries.
Your notes should answer practical questions: What type is being referenced? Which namespace contains it? Is a member inherited, overridden, or newly defined? What does a class expose to callers? Draw a small hierarchy and then locate the same types in a working project. This is more useful than copying definitions without seeing how the pieces interact.
Managed code and memory management
Review the theory behind managed code and .NET memory management at a foundational level. The official preparation guide identified managed-code theory and .NET memory management as knowledge areas, along with core .NET knowledge and language parity. Focus on the difference between code executed under the .NET runtime’s management and code that directly controls lower-level resources.
Avoid turning this topic into an attempt to memorize implementation trivia. Instead, explain object lifetime, references, and why resource cleanup may require explicit handling even when memory is managed. Compare equivalent ideas in C# and Visual Basic .NET where appropriate, because the guide identified language parity as part of the knowledge area.
Application settings and configuration files
Learn the role of basic application settings and the distinction between app.config and web.config. The official objective domain explicitly included these files. Your goal is to recognize why configuration is separated from application logic, what kind of setting belongs there, and how an application or web application uses configuration information.
Create a simple configuration example and trace how the application reads it. Then change a setting without changing the core code and explain the result. Keep the exercise conceptual and version-aware: the historical objective tells you the files to understand, but it does not establish that every modern .NET project uses them in the same way.
Events, event handlers, and delegates
Events are a separate reasoning problem from ordinary method calls. The official objective domain included event-driven programming, event handlers, raising events, and delegates. Study the relationship among the publisher, the event, the delegate signature, and the subscriber’s handler, then practice tracing the order in which an event is raised and handled.
Write a small example in which one object raises an event and another responds. Identify the method that subscribes, the delegate-compatible signature, and the code that triggers the event. A common mistake is to treat a delegate as the event itself; your notes should state what each one represents and how they work together.
Structured exception handling
Learn how structured exception handling represents failures in a .NET application. The official objectives included exceptions and exception types. Preparation should cover how an exception is thrown or propagated, how handling blocks respond, and why selecting an appropriate exception type improves diagnosis and control flow.
Use a deliberately failing example and document the path from the fault to the handling code. Distinguish expected validation failures from unexpected faults, and avoid catching everything without a reason. The exam objective is foundational, so prioritize identifying the mechanism and reading the flow of code over memorizing a long list of framework-specific exception names.
How should you prepare with hands-on work?
Use short, targeted coding exercises alongside reading. The official preparation guide recommended hands-on experience through training, tutorials, samples, MSDN, or Microsoft Visual Studio. For a retired exam, hands-on practice is especially important because it tests whether you understand the concept instead of merely recognizing a phrase associated with an old objective.
Keep each exercise narrow. One project can demonstrate namespaces and inheritance; another can read a configuration value; a third can raise and handle an event; a fourth can throw and handle an exception. After each exercise, write a plain-language explanation of the execution path and one change that would alter the result.
A four-project practice set
Project one should contain a small class hierarchy. Use a base type and a derived type, then identify inherited members and the point at which specialized behavior is introduced. Project two should move a basic setting into app.config or web.config and read it from the application. These exercises anchor the organization and configuration objectives in visible code.
Project three should model an event publisher and subscriber. Have the publisher raise an event after a simple state change, then trace the delegate-compatible handler. Project four should include a controlled exception and a handler for an appropriate exception type. Keep the code readable; the purpose is to reason about .NET behavior, not to create a production application.
How to use Microsoft Learn now
Microsoft Learn provides self-directed modules and learning paths that can support foundational study, and its training site describes learning in short interactive units as well as longer paths. Because 98-372 is retired, search Microsoft Learn for current .NET and developer learning content rather than assuming that a former MTA course is still maintained or aligned to a current exam.
Save useful learning paths or modules to a personal collection when the site allows it. Microsoft’s course-retirement guidance notes that retired course pages may be removed while learning paths and modules can remain available for reference in many cases. Check the current page before building a long plan around older material.
What study mistakes should you avoid?
The biggest mistake is preparing as though 98-372 were an active exam. Retirement means that a high score on a practice product, a claimed exam appointment, or a memorized answer set cannot create a new Microsoft credential. The second mistake is treating the objective list as vocabulary only; the topics are easier to retain when you can trace them through working code.
Avoid exam-dump material and purported leaked questions. Such content is not a substitute for learning, may be inaccurate or unauthorized, and cannot guarantee a pass. Use official objective information, Microsoft training, documentation, and your own controlled exercises. Do not infer current platform behavior from an old question without checking current technical guidance.
Common conceptual traps
Do not confuse a namespace with a class, a class with an object, a delegate with an event, or managed memory with complete resource management. These pairs are related but not interchangeable. Write a one-sentence distinction for each pair and confirm it by locating the relevant construct in code.
Do not study configuration files without asking who consumes the setting, and do not study exception handling without tracing where the exception travels. Finally, do not compare C# and Visual Basic .NET by surface syntax alone. Language parity means understanding the underlying .NET concepts across supported language expressions, not memorizing cosmetic translations.
How to check whether a resource is trustworthy
Start with the official objective document and Microsoft’s retirement pages. A useful resource should identify the historical exam accurately, explain concepts rather than sell certainty, and avoid claims about current scheduling unless an official provider confirms them. Be cautious when a page supplies precise exam facts that are absent from the official material supplied for this guide.
Record the source and the date you reviewed it. Technology documentation changes, and Microsoft’s retirement guidance explains that certifications, exams, and courses are reviewed as technology and job roles change. This habit helps you separate a historical study reference from current certification information.
What is a practical study roadmap?
A four-stage roadmap works well for historical 98-372 preparation: establish language fluency, map the objective areas, build focused exercises, and verify understanding through explanation. The final stage should also make a career decision: either transfer the foundations into current .NET training or stop studying for the retired exam because your actual goal was a current certification.
Do not set an invented number of days or hours as an official schedule. Adjust the pace to your prior programming experience, the amount of time available, and whether you are studying for general knowledge or moving toward a current Microsoft pathway. The sequence matters more than an arbitrary calendar.
Stage one: confirm the foundation
Begin with C# or Visual Basic .NET fundamentals. Review types, variables, control flow, methods, classes, and basic debugging. Then read a small .NET application until you can identify the namespace, class, entry point or event path, and the objects involved.
If you cannot follow the code, do not compensate by memorizing objective terms. Use Microsoft Learn’s current training catalog or another reliable instructional resource to close the language gap first. Return to the 98-372 objective document only after the language constructs are recognizable.
Stage two: map and prioritize the objectives
Create a matrix with one row for each supported knowledge area: class and namespace organization, core .NET concepts, managed code, memory management, language parity, application settings, events and delegates, and structured exception handling. Add columns for definition, code example, explanation in your own words, and remaining questions.
Because the supplied evidence does not provide domain weights, prioritize by weakness and dependency rather than by made-up percentages. For example, class and namespace understanding supports later work with events and exception types, while language familiarity makes the entire objective set easier to read.
Stage three: build and explain
Implement the four small exercises described above, but revise them rather than merely completing them once. Change the inheritance relationship, alter a configuration value, add a second event subscriber, and replace one exception path with another. For every change, predict the result before running the code.
Keep a troubleshooting log. Each entry should state the observed behavior, the mistaken assumption, the relevant .NET concept, and the corrected explanation. This creates a compact review resource and exposes gaps that passive reading tends to hide.
Stage four: transfer the knowledge
Finish by selecting a current learning direction. Microsoft’s retirement FAQ explains that newer fundamentals certifications are intended as starting points and can lead toward role-based training across areas such as Azure, AI, data, Power Platform, Microsoft 365, and Dynamics. Choose based on the type of development or technology work you want to pursue, not on the retired exam number alone.
If your goal is specifically modern .NET development, continue with current .NET documentation and Microsoft Learn content, then verify any certification choice on the current Microsoft credentials pages. The 98-372 objectives can provide vocabulary and conceptual scaffolding, but they should not be treated as a current syllabus.
Can you still use the old objectives for revision?
Yes, but use them as a historical checklist rather than a promise of exam coverage today. The official objective document is valuable for organizing foundational topics, especially class organization, managed code, configuration, events, delegates, and exceptions. Pair every checklist item with a working example and a current explanation before treating the concept as understood.
Mark each item with one of three labels: explain, demonstrate, or revisit. “Explain” means you can define it accurately; “demonstrate” means you can show it in code; “revisit” means you recognize the term but cannot yet trace its behavior. This simple distinction prevents false confidence from repeated reading.
A review question set
Ask yourself: How do namespaces and class libraries support organization? What is inherited in a class hierarchy? What makes code managed? How does an application obtain a setting from configuration? What is the relationship between an event and its handler? What role does a delegate play? How does an exception move through structured handling?
Answer without opening your notes, then test the answer against a small program or authoritative documentation. If the answer depends on an unverified historical detail, label it as historical rather than presenting it as current .NET behavior. This is a better review method than attempting to reconstruct retired exam questions.
What should you do before pursuing a Microsoft credential?
First, confirm that the credential is active and that its official page describes a current scheduling route. Microsoft’s scheduling guidance directs candidates from a certification or exam detail page to the appropriate exam provider, but that process does not make a retired MTA exam available. For current exams, follow the provider shown on the live official page.
Second, check the current skills measured, prerequisites or recommended experience, delivery choices, accommodations process, and any applicable policies on official pages. Do not transfer old MTA assumptions to a newer credential. A current role-based or fundamentals certification may assess different products, workflows, and practical abilities.
Delivery information and scheduling caution
Microsoft’s general scheduling guidance says that current certification exams may present provider choices and, in most cases, may offer an online or local test-center option. It also explains that online exams require a system pre-check and that Certiport does not offer online proctored exams. Those are general current scheduling instructions, not evidence that Exam 98-372 can be booked today.
The same guidance says current exams can be scheduled no more than 90 days in advance and describes provider selection for Pearson VUE or Certiport. Use those instructions only after locating a live official exam page. If 98-372 does not appear as an active exam with a provider scheduling button, stop there and select a current alternative.
Your immediate next actions
Open the official MTA retirement information and confirm the status before spending money. Then open the 98-372 objective document and make the concept matrix. Complete one small exercise for each major cluster, save the explanations, and choose a current Microsoft Learn path that matches your intended developer direction.
If you already earned 98-372, verify that it appears in your Microsoft transcript and describe it accurately as an MTA-era credential. If you never earned it, use the objectives for learning only and direct your certification effort toward a currently available credential. This protects both your time and the accuracy of your professional record.
Conclusion
Exam 98-372 remains useful as a map of introductory .NET ideas, but it is not a current scheduling target. The evidence supports a focused learning plan built around namespaces, classes, managed code, memory, configuration, events, delegates, and exceptions, with hands-on practice in C# or Visual Basic .NET. Use the official objective document to learn the foundations, confirm retirement before taking any administrative action, and then transfer those foundations into a current Microsoft Learn pathway and active credential.
