Exam 98-362, Windows Development Fundamentals, validates foundational Windows programming and application-development knowledge. It is aimed at learners who want to demonstrate early .NET Windows-development capability, particularly with a Microsoft .NET language such as C# or Visual Basic .NET. This guide helps you decide whether the published scope fits your background, build practical evidence of each skill area, and confirm whether a scheduling path is currently available before committing to preparation.
Decide whether 98-362 matches your goal
98-362 is an entry-level Windows-development exam, not a broad measure of modern software engineering or a substitute for a project portfolio. Choose it if your immediate objective is to validate foundational knowledge of Windows programming and application development; choose a different learning route if your goal is centered on a technology outside the published Windows application scope.
Microsoft titles the exam “Windows Development Fundamentals.” MTA pathway material places it in an entry-level training and certification program that covers IT infrastructure, database, and software-development fundamentals. The accompanying preparation guide describes the intended candidate as someone seeking to prove Windows programming and application-development knowledge and skills.
The best fit is a learner who can already read and modify simple code in a Microsoft .NET language and wants structure around traditional Windows application concepts. The official guide expects some experience with C# or Microsoft Visual Basic .NET and recommends foundational knowledge of the listed topics before taking the exam. That expectation matters: starting from zero with both programming syntax and desktop application architecture can make the scope feel fragmented.
Before investing heavily, write down the outcome you need. A student building a first Windows desktop project may use the objectives as a curriculum checklist. A candidate adding an entry-level credential to an academic record may want to confirm local availability first. A working developer pursuing a current platform-specific role should compare the published skills with the technologies used in the target role rather than assume an older fundamentals exam will cover them.
Do not treat the exam title as evidence that it teaches every aspect of application development. The supplied objective material is specifically focused on Windows application types, graphical interfaces, Windows Services, data access for a Windows application, and deployment. It does not support assumptions about web, cloud, mobile, or contemporary cross-platform development coverage.
Check availability before setting a study deadline
The supplied research does not establish that 98-362 is currently available, retired, or schedulable. Confirm its status and delivery options through the relevant official scheduling route before you buy training, book travel, or promise an exam date to an employer or school.
There is a meaningful signal to investigate: Certiport’s current MTA Objective Domains page displays several MTA objective downloads but does not list 98-362 among the displayed downloads. That does not, by itself, prove retirement or unavailability. It does mean the older 98-362 preparation PDF should be used as a scope reference, while current availability must be checked separately.
If the exam cannot be scheduled, the study work can still be useful. Preserve your notes, small applications, and source code as evidence of learning. Then select a currently offered training or certification option based on your next technical goal instead of trying to force a schedule around an unverified listing.
Map the published skills to working knowledge
The preparation guide groups 98-362 around the life cycle of a Windows application: select an application type, create the project, design the interface, add behavior, work with data or services, and deploy the result. Prepare to explain the purpose and relationship of these pieces, then prove that understanding in small builds.
The stated application types are Windows Forms, Windows Presentation Foundation (WPF), Windows Services, and Win32 applications. Do not reduce this to a list to memorize. For each type, make a one-page comparison in your own words: what kind of Windows application it represents, what role its user interface or background behavior has, and why a developer would need to distinguish it from the others. Keep the comparison tied to the terms in the official scope rather than adding unverified exam objectives.
Visual Studio is explicitly included. You should be able to create a Windows-based application and identify project types and application-project components. A useful practice task is to create a small project, inspect its files and settings, and narrate what each major component contributes. When something changes after you add a form, reference, resource, or configuration setting, record the change. This turns a vague familiarity with the IDE into an organized mental model.
User-interface design principles for graphical Windows applications are also in scope. Practice by taking a plain form and improving the arrangement, labels, control choice, and feedback without making the application more complicated. The point is not artistic design. It is to connect an interface decision with a user task: entering a value, triggering an action, reading a result, or recognizing an error.
The guide also names deployment to target computers. Build a short deployment checklist for your own sample application: identify what must accompany the application, what environment it needs, and how you would verify that it runs after installation. Avoid presenting a successful run on your development computer as deployment evidence; the official scope specifically refers to successful deployment to target computers.
Treat the objective guide as a boundary, not a question bank
The official document identifies areas of knowledge, not live questions or a promise of exact task wording. Use it to decide what to build and review, then use your own explanations and code changes to test understanding.
A reliable self-check is to ask three questions for every line of the published scope: Can I define the concept plainly? Can I locate it in a small Windows application? Can I change something related to it and explain the result? A missed answer tells you what to revisit. This approach is more useful than repeatedly recognizing familiar terms in notes.
Do not rely on purported exam dumps, recalled items, or leaked content. They do not build the reasoning needed to work through an unfamiliar scenario, and they can distract from the published skills. Use legitimate practice material, documentation, and your own projects to diagnose gaps instead.
Build Windows Forms skills through one small application
A compact Windows Forms application is the most efficient practice vehicle for several named objectives: graphical user-interface design, event handling, inheritance, visual inheritance, and creating or extending controls. Keep its feature set small enough that you can rebuild it and explain every decision.
Start with a task that has clear inputs, an action, and visible output. For example, create a simple desktop tracker with fields for an item name and status, a button that records a selection, and a display area that shows the result. The application is only a learning vehicle; its value comes from deliberately exercising the published Windows Forms topics rather than from its business complexity.
Create and handle events in the project. Connect a user action to a response, then test what happens when inputs are absent, incomplete, or changed. As you work, identify the event source, the handler, the state the handler reads, and the control it updates. Candidates commonly know that a button “does something” but cannot explain the connection between the action and the application behavior.
Next, use Windows Forms inheritance and visual inheritance in a controlled way. Make a shared base form or common layout for two related screens, then alter one derived form. Your notes should distinguish code inheritance from the design-time visual reuse represented by visual inheritance. If you cannot explain why a change belongs in the base form rather than one derived form, repeat this exercise with a simpler layout.
Finally, create a new graphical control or extend an existing control. Begin with a narrow goal, such as packaging a repeated group of inputs into one reusable control or adding behavior to a familiar control. Resist the temptation to build an elaborate custom interface. The learning objective is to understand reuse, extension, properties, and interaction, not to produce a large codebase.
Avoid the designer-only trap
Using a visual designer can speed construction, but designer actions are not a substitute for understanding the application. Inspect the generated project structure and the properties that determine how controls appear and behave. Then make a small change in a deliberate way and verify its effect.
A practical review routine is to close the designer, open the relevant code or project component, and trace one interface behavior from the control to the event-handling logic and back to the displayed result. Reopen the designer afterward to see how that behavior is represented visually. This reinforces the relationship between the interface and application code without requiring access to exam content.
Keep a defect log while practicing. Record a symptom, the suspected cause, the fix, and the evidence that the fix worked. This habit prevents a common mistake: treating a working result as proof that you understand why it works.
Separate application types from application responsibilities
The published scope includes Windows Forms, WPF, Windows Services, and Win32 applications because a Windows developer needs to recognize different application models and responsibilities. Study them as distinct concepts, then connect each to the practical behavior it enables.
Windows Forms is directly tied in the objective guide to graphical applications, event handling, form inheritance, visual inheritance, and controls. Use your hands-on project to make that part of the scope concrete. WPF and Win32 should still be reviewed as named Windows application types, even if your primary practice application uses Windows Forms. Do not assume that studying one application type automatically gives you vocabulary and conceptual distinctions for the others.
Windows Services deserve separate treatment because the guide covers programming and hosting Windows Services on a Windows computer. Draft a short scenario in which background work needs to continue independently of an interactive desktop interface. Then explain where the service is hosted and how its purpose differs from the graphical application. Keep the scenario conceptual unless you can safely build and verify it in your own environment.
A common preparation error is to study every Windows technology with equal depth. The evidence supplied for this exam identifies the technologies but does not provide domain weights, question counts, or a scoring blueprint. Allocate time according to your initial diagnostic and the amount of hands-on work needed to explain each objective, not according to invented percentages or third-party claims about exam emphasis.
At the end of this stage, create a decision table with one row per application type. Include its name, its broad purpose in your own terms, the kind of interaction or hosting you associate with it, and one uncertainty to research from legitimate technical learning materials. This table is a study aid, not an assertion of the exam’s undisclosed question distribution.
Use terminology precisely
Precision is especially valuable in a fundamentals exam. “Windows application” is a broad category in the official scope; Windows Forms, WPF, Windows Services, and Win32 are named application types within that broader area. Do not use the labels as if they were interchangeable.
Likewise, distinguish a visible graphical control from the form that contains it, and distinguish a background service from a user-interface application. Make flashcards that require a short explanation rather than a one-word label. If a card can be answered only by reciting a definition, add an example from your own practice project.
Practice data access and deployment as end-to-end work
98-362 covers accessing data from various sources for use in a Windows-based application and deploying a Windows application successfully to target computers. Practice these as connected responsibilities: an application must obtain useful information, present or process it, and then run outside the development setup.
For data access, choose a modest sample data source that you can control. Define what information the application needs, where it originates, how the application retrieves it, and how the interface reflects a successful or unsuccessful result. The official guide says “various sources,” but the supplied research does not specify named technologies, connection methods, or data formats. Do not pad your study plan with unsupported claims that a particular provider or API is required.
Test the unhappy paths as well as the intended result. What should the application display if a record is missing, an expected value is not present, or the data cannot be used? You do not need to invent complex infrastructure to learn this lesson. A simple, reproducible failure condition is enough to make you consider the relationship between data, application logic, and interface feedback.
For deployment, take the same practice application to a target computer or a clean environment when possible. Write down the steps you use and the dependencies or configuration decisions you discover. The aim is to understand successful deployment, not merely to create output on the computer where Visual Studio is installed.
Keep your notes honest. A source code repository, screenshots, or a deployment checklist can demonstrate that you practiced, but none is an official substitute for an exam result. Their real value is rapid review: they let you revisit a decision and its outcome when you discover a weak area.
Diagnose failures by layer
When a practice application fails, classify the failure before trying random fixes: project setup, user interface, event behavior, data access, service or hosting behavior, or deployment. This classification mirrors the major responsibilities represented in the published scope and makes study gaps easier to find.
For example, a correct-looking form that never updates may be an event-handling issue rather than a layout issue. An application that works during development but not on the target environment may indicate a deployment question rather than a data-design question. The specific technical cause will vary, but separating the layers prevents unfocused troubleshooting.
Use a staged study roadmap
A useful roadmap starts with a diagnostic, progresses from project foundations to application behavior, and ends with explanation and review. Do not schedule based only on the calendar; schedule when you can complete the published-scope tasks without leaning on copied steps.
First, make a baseline inventory. List the official areas: Windows application types; graphical user-interface design; Visual Studio projects and components; Windows Forms events; form inheritance and visual inheritance; controls; Windows Services; data access; and deployment. Mark each as “can explain,” “can do with notes,” or “new.” This produces a realistic sequence without pretending the exam has published weighting information.
Second, establish your language and environment. Select either C# or Microsoft Visual Basic .NET as the language you will use for most exercises, based on the experience expected by the official guide. Create a straightforward Windows-based application in Visual Studio. Identify its project type and core components before adding features. If this setup is confusing, resolve it now; later work on controls and events depends on it.
Third, construct the graphical application. Apply basic user-interface design principles, add controls, and implement several event-driven actions. Review your code and designer configuration after every change. Include one controlled attempt at Windows Forms inheritance or visual inheritance and one exercise in creating or extending a graphical control.
Fourth, broaden the architecture review. Study the role of WPF, Win32 applications, and Windows Services as named application types. For Windows Services, focus on the guide’s requirement to understand programming and hosting a service on a Windows computer. Use concise notes and a simple scenario rather than trying to turn this stage into an unrelated enterprise-system project.
Fifth, add data access and deployment to the application. Use a data source you can repeat, verify behavior when data is unavailable or unsuitable, and document how you deploy the application to a target environment. This stage reveals gaps hidden by a development machine that already has the required setup.
Finally, run a closed-notes review. Starting with a blank page, sketch the application structure, label the responsibilities of the controls and event handlers, describe the role of each named Windows application type, and explain your deployment steps. Reopen your notes only after you have identified what you cannot reconstruct. That gap list becomes the next review cycle.
Set a readiness rule before scheduling
A sensible readiness rule is based on demonstrated capability, not a target score from an unofficial practice site. Schedule only when you can explain every published area, rebuild your core Windows Forms exercise with limited reference material, and identify a current official scheduling option.
If a legitimate practice assessment is available for the exam you intend to take, use it as a diagnostic rather than as a prediction. Microsoft states that some exams have free Practice Assessments through Microsoft Learn and that availability varies. It also notes that Practice Assessment languages may not match exam languages. Check the actual exam record rather than assuming a tool applies to 98-362.
Leave time after the diagnostic for targeted repair. Rebuild the smallest feature that exposes the weak concept—an event handler, shared form layout, custom control, data retrieval step, or deployment checklist—rather than rereading an entire course. Focused reconstruction is usually a clearer test of understanding than passive review.
Choose legitimate preparation resources carefully
Begin with the official 98-362 preparation guide because it is the supplied source that names the skills. Then select hands-on learning that lets you practice those skills in a Windows application, rather than choosing a resource solely because it advertises large numbers of questions.
Microsoft Learn describes its online modules and tutorials as bite-sized, interactive skill builders that can be completed at an individual pace and are available in multiple languages. Its general preparation page also says that study guides, self-paced resources, exam-prep videos, and Practice Assessments may be available for some exams. These are availability statements, not confirmation that each resource exists for 98-362, so check the current official exam detail route before planning around any named tool.
The Microsoft Learn Software Development Fundamentals video series in the supplied sources is for Exam 98-361, not 98-362. It may be useful for broad introductory software-development context, but it is not evidence of 98-362 coverage. Keep it separate from your 98-362 objective checklist and do not let adjacent exam material replace Windows-development practice.
Use third-party books, courses, and question sets with caution. A resource can be worthwhile when it helps you build, explain, debug, and deploy a Windows application. It is a poor fit when it makes unsupported promises about exact exam content, presents unverifiable scoring claims, or encourages rote answer memorization. Compare every lesson to the official preparation PDF before spending study time on it.
Create an evidence folder for yourself: the official objective document, your application source, a short architecture diagram, a deployment record, and a list of concepts that required rework. This makes revision efficient and creates a useful learning record regardless of the eventual scheduling outcome.
Do not confuse adjacent fundamentals content with this exam
MTA materials identify 98-362 as Windows Development Fundamentals, while the available Microsoft Learn video series is explicitly associated with 98-361 Software Development Fundamentals. Similar labels do not establish identical objectives.
When a resource is labeled for another exam, use it only after identifying the exact concept you need from it. Return immediately to the 98-362 preparation guide to make sure your core study time remains focused on Windows applications, forms, services, data access, and deployment.
Plan scheduling and delivery only after confirmation
Use the official scheduling workflow to confirm whether 98-362 can be booked and which provider options appear for your situation. The supplied general scheduling guidance explains the process, but it does not confirm a current provider, delivery mode, price, language, or appointment availability for this specific exam.
Microsoft directs candidates to begin with the certification overview or certifications listing, select the certification, and use the “Schedule exam” area to choose the provider button. You may be prompted to sign in to or create a Learn Profile. The guidance recommends using a personal Microsoft account and says the legal name in the profile must match legal identification for the appointment.
Provider selection depends on the options that actually appear. Microsoft’s general guidance says candidates taking a certification independently or through a training program should select Pearson VUE, while students, members of academic institutions, or Microsoft Office Specialist candidates should select Certiport. It also says multiple provider options may appear in the scheduling section. Because 98-362 has its own historical MTA context, do not infer a provider from general rules alone; verify the listing you can access.
Microsoft says certification exams can be scheduled no more than 90 days in advance. It also says that, through Pearson VUE, a candidate can have a maximum of two Microsoft Certification exams scheduled at a time. These scheduling rules do not establish that 98-362 is currently available, so treat availability confirmation as the first checkpoint.
If online delivery is offered, complete the required system pre-check for the computer you will use. Microsoft states that if an online option does not appear, it is not available from that exam provider. Its guidance also says Certiport does not offer online proctored exams at this time. A test center can be preferable when you want a pre-configured environment; an online appointment places responsibility on you to meet computer and exam-area security requirements.
Make the appointment decision practical
Book only after you know which provider, location or online option, identification requirements, and appointment management tools apply to the actual listing. Do not make plans around unverified assumptions about price, duration, question count, passing score, language, or retake policy; none is established for 98-362 in the supplied research.
If you need an accommodation, Microsoft advises requesting it before scheduling so the provider has time to review the request and ensure the testing environment can support it. If you are eligible for a scheduled appointment, Microsoft says your Learn Profile can be used to reschedule, cancel, or begin a scheduled online exam, subject to the provider and appointment details shown there.
Microsoft also offers an exam sandbox so candidates can experience the general look and feel of an exam before taking it. The sandbox can help reduce uncertainty about the interface, but it is not a content study tool and does not confirm anything about 98-362 availability or question format.
Finish with a decision checklist
Your next action should be a clear yes, not yet, or redirect decision. A strong decision is based on the current official listing and your ability to perform the published skills, not on a vague feeling of familiarity with desktop-development terminology.
Choose “yes, pursue it” when you have confirmed a current scheduling path, have experience with C# or Visual Basic .NET, can build and explain a small Windows-based application in Visual Studio, and can account for every topic in the preparation guide. Your final review should focus on weak links between interface design, events, controls, data access, service concepts, and deployment.
Choose “not yet” when you still depend on copied project steps, cannot explain the distinction among the named Windows application types, or have not tested data access and deployment outside your initial build. Return to the smallest relevant exercise and rebuild it until you can describe the reasoning behind it.
Choose “redirect” when the exam cannot be verified as available or its Windows-focused scope no longer serves your learning objective. Keep the practical work you completed, because a simple Windows application with documented decisions remains more useful than abandoned notes. Then find a current official offering that matches the technology and role you actually plan to pursue.
The official 98-362 preparation document remains the authoritative scope reference within the supplied research. Use it to keep study disciplined, and use the current official scheduling route to settle availability before making any exam-day commitment.
Conclusion
98-362 is best approached as a focused foundation in Windows application development. Build one small Windows Forms application, use it to practice interfaces, events, inheritance, controls, data access, and deployment, and separately explain the roles of WPF, Win32 applications, and Windows Services. Most importantly, verify current availability through the official scheduling path before treating the exam as a bookable credential.
