98-361 Software Development Fundamentals Exam Guide
Exam 98-361, Software Development Fundamentals, was an introductory Microsoft Technology Associate exam for people building a software-development foundation. It covered general development concepts, programming, object-oriented ideas, web and desktop applications, and databases. The key decision for a candidate now is not simply how to study: Microsoft retired MTA exams on June 30, 2022. This guide explains what 98-361 was designed to validate, how to use its official objectives and learning material for structured study, and when to stop pursuing it as a current credential.
What did 98-361 validate?
98-361 validated introductory knowledge across the software-development lifecycle and common application-development concepts. Microsoft positioned Software Development Fundamentals as an entry point for people intending to build a career as software developers, rather than as a specialist assessment of one programming language or production role.
The official Microsoft learning series describes the content as introductory-level material covering fundamental concepts that software developers need to know. Its topic sequence includes general software development, core programming, object-oriented programming, web applications, desktop applications, and databases.
That scope matters when interpreting the credential. A candidate could use 98-361 to organize foundational learning, but passing it would not by itself demonstrate advanced framework expertise, professional application architecture, or extensive hands-on delivery experience. Treat the exam as a fundamentals checkpoint, not a substitute for building software.
Is 98-361 still available?
No. Microsoft’s MTA Retirement FAQs state that MTA exams retired on June 30, 2022. Candidates had to pass the required exam before that date to earn the certification. A new candidate should therefore verify the current Microsoft certification path instead of attempting to purchase a 98-361 voucher or plan a new appointment.
The retirement is an official status decision, not a study disadvantage that can be overcome with more preparation. Microsoft explained that MTA was being replaced by newer certifications focused on job roles and recommended that educators, students, and learners pivot toward that newer generation of credentials.
Existing holders are treated differently from new candidates. Microsoft states that certifications already earned remain on the certification transcript and remain printable after retirement, although they move to the Certification History section two years after the certifications retire. That information is useful when reviewing an old résumé or transcript.
What should a new learner do instead?
Use the 98-361 objectives only if you need a historical syllabus, a school assignment, or a foundation for understanding older Microsoft developer certification material. For a current credential, begin with Microsoft Learn’s current certification catalogue and select a role- or technology-aligned fundamentals path that is available now.
Do not assume that a replacement has the same title, scope, exam code, delivery provider, or assessment format. Those details change, so confirm them on the current Microsoft certification-detail page before buying training or scheduling an exam.
Who was the intended audience?
98-361 was aimed at beginners, students, career changers, and people exploring a technology career who needed a first formal measure of software-development knowledge. Microsoft’s support material specifically places the MTA Developer certifications within a path for individuals intending to build a career as software developers.
The audience description points to an appropriate preparation level: you do not need to begin with advanced specialization, but you do need enough technical vocabulary to explain how programs are designed, executed, tested, connected to data, and delivered through different application types.
A useful readiness test is whether you can explain a concept and apply it to a small example without copying a memorized definition. If you can name a programming construct but cannot predict what a short piece of code will do, your preparation should emphasize practice rather than additional reading.
For educators, 98-361 also offered a curriculum anchor. Certiport listed a dedicated Software Development Fundamentals study guide and an objective-domain document. Those resources can still help an instructor map introductory lessons, provided the retirement status is made clear to students.
Which skills and domains were covered?
The official Microsoft learning series identifies six practical topic areas: general software development, core programming, object-oriented programming, web applications, desktop applications, and databases. These are the safest high-level skill groups to use when reconstructing a study plan because they come directly from Microsoft’s 98-361 learning material.
General software development concerns the vocabulary and process surrounding application creation. Study the purpose of requirements, design, implementation, testing, debugging, maintenance, and source control at an introductory level. The goal is to understand how these activities relate, not to memorize an isolated list.
Core programming is the area where you should become comfortable tracing logic. Work with variables, data types, operators, conditions, loops, methods or functions, collections, input and output, exceptions, and basic debugging. Use short programs and predict their results before running them.
Object-oriented programming requires more than knowing the words class and object. Prepare to distinguish a class from an instance, describe encapsulation, inheritance, and polymorphism, and identify how responsibilities can be divided among objects. Keep examples small enough that you can explain each member and relationship.
Web applications and desktop applications test different application contexts. Compare where code runs, how a user interacts with the application, how state and input are handled, and how the application communicates with services or data. Avoid reducing the distinction to a particular tool or framework.
Database fundamentals should be studied as an application concern rather than as an isolated administration subject. Review tables, records, fields, keys, relationships, queries, and the way an application reads or writes persistent data. Practice identifying which data operation a scenario requires and what a relational structure is intended to represent.
The official Certiport objective-domain page identifies 98-361 as Software Development Fundamentals and links to the downloadable objective document. Use that document as the controlling checklist for historical 98-361 study. The learning series supplies explanation and sequence; the objective document supplies the boundary of the assessed topics.
No verified source supplied here gives percentage weights for these six topic areas. Do not create a percentage-based timetable or compare bare percentages. Divide study time according to your diagnostic results and the detail in the official objective document instead.
How should you turn the objectives into a study plan?
Start with the objective document, convert each objective into a question you can answer, and then test the answer with a small code or design exercise. This approach prevents passive reading and makes weak areas visible before you spend time polishing topics you already understand.
Create a three-column working sheet: objective, evidence of competence, and unresolved questions. In the evidence column, write something observable, such as “trace a loop with a changing counter,” “explain why a class hides an implementation detail,” or “identify a key that links related records.”
Next, classify every objective as known, partly known, or unfamiliar. “Known” should mean that you can explain it and use it, not merely recognize its terminology. “Partly known” is the category that usually deserves the most attention because recognition can create false confidence.
Study in dependency order. Begin with general development concepts and core programming. Move to object-oriented programming once you can follow control flow and data movement. Then connect those ideas to web and desktop applications, and finish with database scenarios that require you to reason about application data.
Keep a separate error log. For every missed exercise, record the concept, the mistaken assumption, the correct reasoning, and one new example. Review the error log at the start of the next session. Repeated errors are more useful scheduling signals than the number of pages you have read.
A practical sequence for mixed experience
If you have never programmed, spend the first phase learning control flow and data representation with very small programs. Do not begin by switching among several languages. One consistent syntax is enough to make logic visible while you learn the underlying concepts.
If you have programmed before but lack Microsoft-platform exposure, focus on vocabulary and application context. You may already understand loops and methods, yet still need to distinguish desktop and web application concerns or explain how a database supports an application.
If you have built applications professionally, resist skipping the fundamentals. Use the objective list as a coverage audit, especially for terminology, object-oriented principles, and database concepts that your daily framework may hide. Your risk is often breadth gaps rather than inability to write code.
What should hands-on practice look like?
Hands-on work should be small, deliberate, and tied to an objective. Build or inspect short programs that accept input, transform data, make decisions, repeat an operation, and report errors. Then refactor one example into separate methods or classes so you can observe how design choices affect readability and responsibility.
For programming practice, use a trace-first routine. Read the code, write down the initial values, follow each condition and loop, and predict the final state. Run the program only after making the prediction. When the result differs, explain the exact line where your mental model diverged.
For object-oriented practice, design a modest domain such as a library, appointment list, or inventory record. Identify the objects, their data, and their operations. Ask which details should remain internal and which behavior should be exposed. Then change one requirement and observe whether the design absorbs the change cleanly.
For web and desktop practice, compare the same simple feature in both contexts. Describe the user interaction, where validation occurs, how state is maintained, and how the application reaches stored data. This comparison develops transferable understanding without claiming that the retired exam required a particular framework.
For database practice, sketch a relational model before writing queries. Identify entities, attributes, keys, and relationships. Create scenarios such as finding related records, adding a new record, changing a value, and removing an obsolete record. Explain what the application expects to receive from each operation.
Use official learning material to clarify concepts, but do not treat watching a lesson as proof of readiness. After each lesson or reading session, close the material and complete a recall task. The Microsoft learning series is an overview of concepts expected for 98-361, while the Certiport objective document is the better checklist for coverage.
How can you prepare without official practice exams?
Certiport’s MTA FAQ states that practice exams were not available for MTA. That makes objective-based self-testing especially important. Build your own questions from the official objectives, answer them from memory, and require an explanation for every answer rather than relying on recognition alone.
A good self-test mixes definition, interpretation, and application. Ask what a term means, ask how two related concepts differ, and ask what a developer should do in a short scenario. For code, include tracing and error diagnosis. For databases, include structure and operation selection. For application types, include comparison questions.
Avoid any material advertised as leaked questions, exam dumps, or a guarantee of passing. Such material cannot replace understanding, may be inaccurate or unauthorized, and encourages memorization of answers instead of competence. Practice should expose reasoning gaps, not imitate access to live exam content.
After each self-test, sort mistakes into three causes: missing knowledge, misread wording, or faulty reasoning. A missing-knowledge error calls for study. A wording error calls for slower reading and identification of the question’s subject. A reasoning error calls for another worked example completed step by step.
Do not infer a pass from a single informal quiz. Use several rounds of questions written in different wording, and revisit earlier weak areas after a delay. Confidence should come from consistent explanations and successful application across the objective list, not from a high score on repeated questions.
What historical exam details are documented?
Archived Certiport FAQ material states that MTA certification exams typically ranged between 30 and 50 questions and that candidates had 50 minutes to complete an MTA Certification exam. These are historical program details, not a basis for scheduling 98-361 now, because the MTA exams retired on June 30, 2022.
The same FAQ states that MTA exams used a scaled passing score of 70. It also warns that the percentage of items answered correctly could be more or less than 70 percent because the cut score was established through subject-matter-expert input. Therefore, do not translate a scaled score into an assumed item percentage.
Archived scoring guidance describes the score report’s bars as relative performance indicators for subject areas, with longer bars representing stronger performance. A weak bar should guide review, but it should not be treated as a precise estimate of the number of missed questions, especially where a section contains relatively few questions.
The FAQ also states that the score report was shown immediately after completing the exam and was available on the Certiport website for reference. Because these statements come from legacy MTA material, confirm any requirement with the current provider if you are researching a historical record or another active exam.
What delivery and registration issues mattered?
The official Microsoft registration guidance explains a general process: open the relevant certification or exam-detail page, select Schedule exam, and choose the provider shown there. It distinguishes Pearson VUE for candidates taking Microsoft certifications independently or through training from Certiport for students, academic-institution members, or Microsoft Office Specialist candidates.
That current guidance does not make 98-361 schedulable. The MTA retirement information takes priority for this exam code. Do not use a current provider workflow as evidence that a retired exam has returned, and do not rely on an old booking link without confirming the exam’s status on an official Microsoft or Certiport page.
For active Microsoft exams, the registration guidance says candidates may be prompted to sign in or create a Learn Profile and should ensure the legal name matches legal identification. It also explains that online testing requires a system pre-check and a compliant testing environment, while a test center avoids the need to prepare the candidate’s own computer for online security requirements.
Those logistics are practical lessons for choosing a future exam, not 98-361 delivery facts. If you need accommodations, Microsoft’s guidance says to request them before scheduling so the provider has time to review the request and support the testing environment.
Which mistakes most often waste preparation time?
The costliest mistake is studying as if 98-361 were an active exam. Check retirement status first. Once you confirm that the exam retired on June 30, 2022, decide whether your purpose is historical study, curriculum planning, or pursuing a current credential. That decision prevents wasted spending on unavailable vouchers and outdated booking advice.
Another mistake is treating the topic names as a syllabus. “Core programming” can include many distinct ideas, and recognizing a term is not the same as tracing code or selecting an appropriate design. Break each official objective into an observable task and record evidence that you can perform it.
Many candidates also over-focus on one familiar language. The verified material describes foundational software-development concepts, not a promise that one language will represent every question. Learn the concept first, then use code to make it concrete. Avoid spending most of your time on syntax that is not tied to an objective.
A further error is postponing databases and application types because programming feels more central. Web applications, desktop applications, and databases are explicitly included in the official learning series. Give them planned study sessions, then connect them to programming through small scenarios.
Finally, do not use the archived passing score as a target for guessing item percentages. The FAQ explains scaled scoring and cautions that the actual percentage needed can vary. Use the official objective coverage and your ability to explain solutions as readiness measures.
What does a focused study roadmap look like?
A focused roadmap has four cycles: map, learn, apply, and audit. Start by mapping the official objectives, learn the unfamiliar concepts, apply them in short exercises, and audit every objective again. Since 98-361 is retired, add a decision checkpoint at the beginning and end: continue only if you have a legitimate historical or educational reason.
In the map cycle, download the 98-361 study guide or objective document from the official Certiport resource, list each objective, and mark your confidence. Watch or review the Microsoft Software Development Fundamentals material to identify vocabulary that needs clarification. Do not schedule anything; the exam is retired.
In the learn cycle, cover general development and core programming first. Practise variables, control flow, data structures, methods, error handling, and debugging. Write short explanations in your own words. When a concept remains unclear, create a smaller example instead of immediately adding another course or reference.
In the apply cycle, add object-oriented exercises, then compare web and desktop application scenarios. Finish with database modelling and data-operation exercises. At the end of each session, answer several questions without notes and update the error log. The point is transfer: using a concept in a new situation.
In the audit cycle, work through the entire objective list in a mixed order. Explain why each answer is correct, identify distractors or alternative interpretations, and return to the weakest objective. If you are using the material to prepare for a modern certification, now map these fundamentals to the current certification’s official skills outline rather than assuming equivalence.
A sensible weekly rhythm is three kinds of sessions: concept review, hands-on application, and cumulative recall. Keep the sessions distinct so that reading does not crowd out practice. Adjust the balance after each audit: more application for code-tracing errors, more comparison exercises for architecture vocabulary, and more modelling for database confusion.
A final readiness checklist for historical study
You are ready to finish a historical 98-361 learning project when you can explain the purpose of each official topic area, trace unfamiliar introductory code, distinguish core object-oriented concepts, compare web and desktop application concerns, and describe how relational data supports an application.
You should also be able to point to the objective document and show which evidence supports each item. If your only evidence is that you watched a lesson or recognized a term, the topic is not yet demonstrated. Complete one new example, explain it without notes, and record the result.
For a current certification decision, readiness means something different: you have identified an available Microsoft certification, read its current skills outline, confirmed its provider and eligibility details, and built a study plan around that exam rather than around retired 98-361 assumptions.
What should you do next?
First, decide whether you need 98-361 for historical curriculum work or whether you are seeking a live credential. A new credential candidate should move to Microsoft’s current certification catalogue because Exam 98-361 and the MTA program retired on June 30, 2022.
If you are studying the fundamentals, download the official 98-361 objective document, use the Microsoft learning series for conceptual orientation, and create an objective-by-objective evidence sheet. Begin with core programming, then connect object-oriented design, application types, and databases through small exercises.
If you already earned the certification, check your Microsoft transcript rather than trying to retake the exam. Microsoft states that earned MTA certifications remain on the transcript and remain printable after retirement. Keep the credential’s historical status clear when presenting it alongside current certifications.
The most reliable preparation resource is the official objective boundary paired with active practice. Use third-party explanations only to clarify a concept, never as proof that an exam is available or as a source of live questions. Then choose a current certification whose official scope matches the software-development direction you want to pursue.
Conclusion
98-361 remains useful as a map of introductory software-development concepts, but it is not a current exam to schedule. Use its official topics to strengthen programming, object-oriented design, application, and database foundations; use Microsoft’s current certification pages for any live credential decision. That separation keeps historical study accurate and prevents outdated exam logistics or unauthorized question sources from shaping your preparation.
