98-361 Software Development Fundamentals: archival exam guide and skills roadmap
Exam 98-361, Software Development Fundamentals, was an introductory Microsoft Technology Associate credential for people seeking to demonstrate core software-development knowledge. It suited students, career changers, and early learners considering a developer path. The practical decision now is not whether to book 98-361: Microsoft retired the MTA exams on June 30, 2022. Use this guide to understand the skills the exam represented, assess your foundation, and choose a current learning direction instead of pursuing obsolete exam materials.
Can you still take 98-361?
No. Microsoft’s MTA Retirement FAQs state that MTA exams retired on June 30, 2022, and candidates had to pass the required exam before that date to earn the certification. Treat any current offer claiming to schedule a new 98-361 attempt with caution rather than assuming it is an authorized route.
paragraphs mistakenly omitted
What 98-361 was designed to validate
98-361 was the MTA Software Development Fundamentals exam, created as an entry-level measure of core software-development skills. Microsoft described its related learning content as introductory-level material focused on fundamental concepts developers need to understand, rather than as a specialist or job-role assessment.
The intended candidate was someone building a base for a software-development career. Microsoft’s MTA material also positioned the broader program for students, career changers, and people exploring technology careers. That makes the historic credential most relevant as a foundation benchmark: it asked whether a learner could recognize and reason about essential development ideas before advancing into a specific platform, language, or role.
The former MTA model combined knowledge and skills, with Certiport describing MTA as 80% knowledge and 20% skills. For present-day study, that distinction is useful. Reading definitions is necessary, but a credible foundation also requires applying concepts in small pieces of code, explaining the result, and diagnosing simple errors.
Do not interpret the retired credential as proof of current expertise with a modern framework, cloud platform, or production engineering process. Its value as a study outline is broader: it can reveal whether foundational gaps in programming logic, application types, or data concepts are likely to slow later learning.
Which skills should you study?
Study the six topic areas associated with Microsoft’s 98-361 learning series: general software development, core programming, object-oriented programming, web applications, desktop applications, and databases. The supplied official material does not provide a verified domain-weight table, so planning should be based on competence across those areas rather than assumed percentages.
General software development should give you a working vocabulary for the lifecycle of an application. Be able to distinguish a requirement from a design decision, identify why testing exists, and explain how maintenance differs from initial implementation. Use a small imagined application, such as a library checkout tool, to connect each concept to a concrete decision rather than memorizing isolated terminology.
Core programming is the best place to test whether your foundation is real. Practice variables, data types, expressions, conditional logic, loops, methods or functions, inputs, outputs, and basic error handling in one language. The language is less important than being able to trace a short program: state what each line changes, predict output, and correct a flawed condition.
Object-oriented programming requires more than reciting class, object, inheritance, and encapsulation. Sketch a compact model with related entities—for example, Account and SavingsAccount—and explain what data and behavior belong together. Then ask whether a relationship represents an “is a” connection or merely a “uses a” connection. This prevents mechanically applying inheritance where composition would be clearer.
Web and desktop applications should be studied as distinct application contexts. For a web application, identify the relationship between a user interface, server-side work, and data. For a desktop application, consider an installed application that responds to local user actions. You do not need to force every project into either category; the aim is to understand the architectural constraints each context creates.
Database study should cover how applications organize and retrieve data. Build a tiny schema on paper, identify a record and a field, and decide what information needs a stable identifier. Then write plain-language questions that data queries would answer, such as which orders belong to a customer. This establishes the bridge between programming logic and persistent data.
How should you assess your starting point?
Assess your readiness by performing small tasks without notes, then recording the reason for every error. The official preparation guide recommends foundational knowledge of the listed topics before attempting 98-361; for a modern learner, the same principle means resolving fundamentals before selecting advanced courses or certification paths.
Start with a diagnostic notebook, not a score target. Create one page for each of the six topic areas. For each page, write a definition in your own words, one example, one question you cannot answer, and one brief practice task. A blank or vague explanation is a more useful signal than a guess on a recall question.
Use code tracing early. Take a short function containing a variable update, a decision, and a loop. Before running it, annotate the variable values after each step and predict the final result. Run the code only after making the prediction. When the result differs, identify whether the gap was syntax, data type behavior, control flow, or a misunderstanding of the requirement.
Include a design exercise alongside coding. Describe a simple application, list its inputs and outputs, choose the data it must retain, and draw two or three candidate classes. This exposes a frequent beginner weakness: learners can write a statement in isolation but cannot explain how program structure, data, and user interaction fit together.
Avoid treating unauthorized question collections as a readiness test. They may be inaccurate, out of date, or disconnected from the underlying skill. A better measure is whether you can explain a concept, apply it in a new example, and correct a deliberately simple mistake without being prompted by an answer key.
A practical study roadmap
Build your foundation in dependency order: programming logic first, then program structure and data, then application contexts. This sequence reduces wasted effort because object-oriented, web, desktop, and database concepts become much easier when you can already trace code and express a basic algorithm.
Begin with core programming. Choose a single beginner-friendly language and create short programs that accept an input, make a decision, repeat an action, and return an output. Keep each exercise small enough that you can explain every line. At the end of this stage, revise a program to handle an invalid input; that introduces defensive thinking without adding unnecessary complexity.
Next, connect code to object-oriented design. Refactor one of the earlier programs so that related data and actions sit together. For instance, instead of separate variables scattered through a program, represent an item with a class and methods that change its state. Write down why each property and method belongs to that class. If you cannot justify it, simplify the design.
Then add persistent data. Model a small set of related records, decide which identifier distinguishes each one, and list the operations the application needs: create, find, change, and remove. Even if you do not install a database system, this design work teaches the reasoning required to move between application code and data storage.
After that, compare delivery contexts. Reuse the same small application idea in two designs: one with a desktop interface and one with a web interface. Identify what remains the same—the business rules and data model—and what changes—the way users access the application and how components communicate. This is more valuable than trying to learn several frameworks at once.
Finish each study cycle with retrieval and correction. Close your notes, explain a topic aloud or in writing, solve one fresh task, and review only the errors. Maintain an error log with the original misconception, the correction, and a new example. Repeating corrected reasoning is more durable than rereading a chapter.
Microsoft’s archived Software Development Fundamentals learning series remains a relevant conceptual resource because it was specifically designed to cover ideas viewers were expected to understand for 98-361. Pair it with hands-on exercises so that passive viewing does not become your entire preparation method.
What historical delivery details are still useful?
Historical delivery information can help interpret old transcripts and study records, but it must not be used to plan a new 98-361 appointment. Certiport’s former MTA FAQ stated that MTA candidates had 50 minutes and that MTA exams typically ranged between 30 and 50 questions.
The same archived FAQ described a scaled passing score of 70 for MTA exams. It also cautioned that this score was not equivalent to answering 70 percent of items correctly; the percentage of correct answers needed could vary by exam. Do not turn an old score convention into a current readiness threshold. Focus instead on whether you can perform the skills represented by the topic areas.
For historic availability, Certiport stated that MTA was available to students, faculty, and staff of an accredited academic institution that was an approved MTA testing center. The FAQ also stated that MTA certification exams were not available through commercial learning institutions at that time. These details explain why older guidance may reference schools and campus administration.
Certiport’s archived FAQ stated that preparation materials were available only in English. Its study-guide page still lists a Software Development Fundamentals 98-361 study guide, and its objective-domain page identifies 98-361 with a downloadable objective document. These documents are appropriate for historical scope checking, but retirement status takes priority over an old preparation link.
Current Microsoft scheduling instructions say candidates normally begin from a certification-detail page and use the appropriate provider button. Those instructions are general scheduling guidance, not evidence that a retired MTA exam can be booked. Microsoft also notes that Certiport does not offer online proctored exams at this time, which reinforces the need to verify the current provider and certification status directly for any active exam you choose.
What should replace an exam booking plan?
Replace a 98-361 booking plan with a skills-and-direction plan. Microsoft recommends that educators, students, and learners pivot from retired MTA certifications to its newer generation of certifications, and identifies Fundamentals certifications as a starting point for foundational understanding of Microsoft technologies.
First decide what you want to build. A learner interested in cloud services needs a different next step from someone who wants to create web interfaces, automate business processes, analyze data, or develop desktop software. Make the choice after completing a small foundation project, because actual work often reveals whether you prefer user interfaces, logic, data, or infrastructure.
Second, preserve evidence of learning in a format that remains useful regardless of a credential. Keep a source repository or organized project folder containing a readme, setup notes, a short explanation of design decisions, and tests or example inputs. A modest completed application demonstrates more actionable progress than a long list of unfinished tutorials.
Third, select current official training and certification material only after confirming that the target credential is active and that its intended audience matches your goal. Read the current skills outline before paying for training. If the outline assumes experience you do not yet have, return to a foundation project rather than trying to compensate with memorized terminology.
If you already earned an MTA credential before retirement, Microsoft states that it remains on your certification transcript and is printable after retirement, though it moves to the Certification History section two years after the certifications retire. Keep a copy of the credential and describe it accurately as a historic foundational certification when presenting it.
Common mistakes to avoid
The largest mistake is preparing as though 98-361 remains an active exam. Retirement changes the goal: use the outline for structured learning and move any certification investment toward an active, verified option that serves your intended role.
Another mistake is choosing several languages, frameworks, and application types at the beginning. That creates vocabulary without fluency. Choose one language for core programming, one small application idea, and one method for recording errors. Expand only after you can alter a program’s logic and explain its behavior without copying a tutorial.
Do not confuse a familiar term with usable understanding. Knowing the definition of encapsulation, for example, is not the same as being able to decide which object should own a piece of data or behavior. For every concept, require yourself to produce an example, explain a counterexample, and make one change to working code.
Avoid planning around historic exam question counts, timing, or score reports. Those facts describe a retired assessment and do not indicate the standards of another exam. A study plan based on demonstrated tasks remains portable: trace code, solve a new problem, model data, explain a design, and review your own errors.
Finally, do not let a retired exam become a reason to stop learning. The original purpose of 98-361 was a first step into software development. The practical equivalent now is a stable set of fundamentals, a small completed project, and an informed choice of a current learning or certification path.
Conclusion
98-361 is no longer an exam you can earn, but its introductory scope still provides a sensible checklist for a beginning developer. Build competence in programming logic first, then connect that logic to object-oriented design, data, and application contexts. Use official archived materials to understand the former scope, avoid obsolete booking claims and unauthorized question sources, and verify the status and objectives of any current certification before committing to it.
