INF-203x Exam Guide: Build an Evidence-Based INF and Driver Installation Study Plan
INF-203x is best approached as an INF-file and Windows driver-installation competency exam: the supplied Microsoft material centers on package structure, model matching, platform targeting, WDF directives, component INFs, extension INFs, and SetupAPI access. The available research does not publish an official blueprint, delivery format, score, or schedule. This guide helps candidates decide what to study first, where to use hands-on practice, and which exam logistics must be confirmed through the current official programme information.
What the supplied evidence says INF-203x is likely to assess
The available evidence points to practical understanding of how Windows identifies, installs, configures, and services driver packages through INF files. It does not provide an official INF-203x objective list, so treat the topic map below as a preparation framework rather than a published exam blueprint.
Microsoft defines an INF file as a text file in a driver package containing the information that device-installation components use to install a driver package on a device. That includes drivers supporting the device and device-specific configuration or settings needed to bring it online. This definition should anchor your study: an INF is not merely a list of copied files; it describes installation behavior and relationships.
The material also covers INX files. An INX file contains variables representing information such as version information, target architecture, and the current Windows Driver Framework version. The Build utility and Stampinf replace those variables with architecture- or framework-specific text when creating an INF. A candidate who can explain why a project uses INX rather than manually maintaining every generated value will be better prepared for design and troubleshooting questions.
Because no verified exam domains or percentages were supplied, do not create a revision timetable based on assumed weighting. Instead, organize study around the dependency chain: identify the device, select the applicable model and install sections, apply platform decorations, configure the driver framework, separate optional software where appropriate, and validate how installation tooling reads the package.
Who should use this guide
This guide is most useful for Windows driver developers, device-software engineers, test engineers, and technical candidates who need to reason about INF-based installation. It is also suitable for administrators or support specialists who regularly inspect driver packages, although the WDF and component-INF material requires more development-oriented study.
Which INF sections deserve first attention
Start with the section relationships rather than memorizing isolated directive names. The most important early exercise is tracing a device from the manufacturer’s Models section to its DDInstall section, then onward to files, registry settings, framework configuration, or component references.
A per-manufacturer Models section identifies at least one device, references the DDInstall section used for that device, and specifies a hardware identifier unique to that model section. Each entry must specify at least one device ID, which may be a hardware ID or compatible ID. Read the Models section as the matching and routing layer of the package.
The documented entry pattern associates a device description with an install-section name and one hardware ID, followed by optional compatible IDs. Hardware IDs can use enumerator-specific formats such as a USB or PCI identifier, a form that applies across more than one enumerator, or a bus-specific device-class format. Compatible IDs identify devices controlled by the same driver as the device named by the initial hardware ID.
Each Models section name must be listed in the INF Manufacturer section, and each install-section name must be unique within the INF. These relationships are ideal for study diagrams. Draw arrows between Manufacturer, Models, hardware identifiers, and DDInstall sections, then annotate where a platform or operating-system decoration changes the selected section.
A useful matching exercise
Create a small fictional device matrix without copying real exam questions. Give each device a manufacturer, a hardware ID, a compatible ID, a target architecture, and an intended install section. Then write the corresponding Models entries and explain which identifier would allow Windows to match the package. The goal is to explain the routing, not to memorize syntax without context.
How to study platform and operating-system decorations
Learn platform decorations as a targeting decision: they determine which section applies to a target platform, so a package can contain one INF while still expressing different installation instructions for different systems.
Microsoft documents decorations including .ntamd64 for x64-based systems supported by Windows XP and later, .ntia64 for Itanium-based systems supported by Windows XP and later, .ntx86 for x86-based systems supported by Windows XP and later, .ntarm for Arm-based systems supported by Windows 8 and later, and .ntarm64 for Arm64-based systems supported by Windows 10 version 1709 and later. Keep each decoration attached to its exact platform and operating-system scope when making notes.
The .nt behavior and an undecorated section have historical behavior that depends on the Windows version. Starting with Windows Server 2003 SP1, an undecorated section describes x86-based systems supported by the operating system, whereas earlier systems treated it differently. For modern study, do not flatten these distinctions into a rule that every undecorated section is universal.
For Windows Server 2003 SP1 and later, non-x86 targets require decorated Models-section entries using the applicable platform extension. Microsoft recommends decorating Models entries for target operating systems of Windows XP and later, and recommends avoiding .nt for x86 hardware platforms in favor of the more explicit platform decoration. This is a good area for contrast tables: target platform, section suffix, and the consequence of omitting it.
A common mistake is decorating a DDInstall section while leaving the Models entry pointed at an incompatible or undecorated route. Practice checking the whole path. The candidate should be able to explain not only what .ntamd64 means, but also where the decoration must appear and why a matching entry matters.
How x64 display-driver examples help
The x64 display-driver reference illustrates architecture-specific destinations and sections. Its example uses NTamd64 in the Manufacturer entry, an architecture-specific Models section, and a separate section for a 32-bit user-mode display component copied to SysWow64. Use this as a reading exercise for architecture-sensitive files and destinations, not as a universal template for every driver package.
How to master WDF directives without mixing KMDF and UMDF
Study WDF installation in two layers: the DDInstall.wdf section declares the framework service relationship, while the referenced wdf-service-install section supplies framework-specific installation information. Keep KMDF and UMDF directives separate in your notes and in any practice INF.
An INF that installs a WDF driver must contain a DDInstall.wdf section for each DDInstall section and a wdf-service-install section whose name is specified by a KmdfService or UmdfService directive in DDInstall.wdf. UMDF-specific directives begin with the UMDF prefix; KMDF-specific directives begin with the KMDF prefix.
For UMDF, UmdfService associates a service name with a referenced service-install section, and UmdfServiceOrder establishes service order in the documented example. The serviceName parameter is limited to a maximum of 31 characters. UmdfLibraryVersion informs the co-installer of the framework version, while ServiceBinary identifies the UMDF binary location in the example.
For KMDF, KmdfService associates the driver with the referenced service-install section, and KmdfLibraryVersion specifies the framework version. Microsoft normally recommends specifying $KMDFVERSION$ so that the WDK build process replaces it with the correct version. Treat that variable as a build-time mechanism rather than a value to invent in an answer.
Do not study directives as a flat glossary. For every directive, record its scope, the section in which it appears, the driver model it affects, and the installation or runtime decision it controls. Then explain what a missing or mismatched directive would prevent the package from expressing.
UMDF versions and USB I/O targets
The supplied evidence gives a specific version boundary for USB dispatching. If a UMDF driver uses USB I/O targets and uses UMDF 2.15 or later, the UmdfDispatcher directive should be set to NativeUSB; for a pre-UMDF 2.15 driver using USB I/O targets, it should be set to WinUsb. Starting with UMDF 2.15, NativeUSB causes the reflector to handle USB I/O.
This is a high-value comparison because it combines driver model, framework version, hardware interface, and directive value. Build a two-column note that keeps the version condition attached to the USB scenario. Avoid memorizing NativeUSB or WinUsb as unconditional choices.
Other UMDF directives in the supplied reference include policies for host-process sharing, direct hardware access, kernel-mode clients, file-object context, register access, and host priority. Learn what decision each policy represents and verify version support before using it in an explanation. For example, UmdfHostPriority is supported in UMDF versions 2.15 and later, while several other directives have different support boundaries.
When a component INF is the right design
Use component-INF study to understand separation of optional device software from the basic function driver. A software component can install one or more software modules that enhance a device without being necessary for basic device functionality or requiring an associated function-driver service.
For Windows 10 DCH-compliant designs, Microsoft describes hardware support apps, software components, and related packaging choices. A hardware support app is device add-on software packaged as a UWP app delivered and serviced from the Microsoft Store. A software component is a separate, standalone driver package that can install software modules such as an MSI or EXE binary, a Win32 service, or software installed through AddReg and CopyFiles; the referenced binary runs on desktop editions and not Windows 10S according to the supplied material.
An extension INF uses AddComponent in the INF DDInstall.Components section. For each referenced software component, Windows creates a virtual software-enumerated child device. More than one driver package can reference the same software component, and virtual children can be updated independently while the parent device is started.
Microsoft recommends separating functionality into groupings that make sense from a servicing perspective and creating one software component for each grouping. This gives you a practical design test: if an optional feature has an independent servicing lifecycle, ask whether it should be separated rather than bundled into the core device installation.
Keep AddSoftware cases distinct. An AddSoftware directive of Type 1 must be used from a Component INF, while Type 2 does not require a Component INF and can be used in any INF that supports it. A component INF that specifies AddSoftware must be universal and must specify the SoftwareComponent setup class.
A software-enumerated component device depends on its parent being started. If no parent driver is available, the documentation describes using a driver created by the developer or the Windows pass-through driver umpass.sys, with Include and Needs directives in the relevant DDInstall sections. Study this as a dependency and installation-order problem, not merely as a special filename to remember.
Design decision checklist
For any proposed optional feature, ask four questions: Is it required for basic device functionality? Does it need a separate update or uninstall path? Is it a software component device or an application better delivered another way? Does the parent device start before the child can function? Your answers should determine the package structure and the installation directives you investigate.
How extension INFs affect servicing and lineage
Extension INF preparation requires more than writing a valid file. You must understand the relationship between the base driver, the extension package, the ExtensionID, versioning, and submission structure.
The ExtensionID is a GUID generated for driver lineage identification and versioning. It is not used for applicability; applicability is determined elsewhere in driver selection. For an initial version of an extension INF, generate a new ExtensionID. When updating an already published extension INF, keep the same ExtensionID and increment the version and/or date specified by DriverVer.
The driver date and driver version differentiate extension INFs with the same ExtensionID, and extension drivers are ranked by the date and version included in DriverVer. Keep these concepts separate in your revision notes: ExtensionID identifies lineage, while DriverVer supplies the versioning information used for comparison and ranking.
When a base-driver update is applied, Windows evaluates the currently installed extension INF and applies it if necessary. If no extension INFs are installed, Windows Update downloads the latest applicable version. This behavior is useful for scenario-based revision because it connects package publication to what happens during a later base-driver update.
The supplied Partner Center guidance recommends a separate submission for each extension INF and a separate submission containing only the base driver. Combining them can cause all shipping labels to be treated as extension drivers and can lead to repeated package downloads when the base driver and applicable extensions are installed. Treat packaging boundaries as a release-management concern, not just an administrative detail.
The research also states that extension INFs can use shipping labels and that automatic driver-promotion selections are required for Windows Update publication because extension INFs are not listed in Device Manager for an end user to initiate an Update Driver action. Verify current Partner Center and Windows Update requirements before scheduling a real submission, because publication workflows can change.
A safe revision exercise
Write two release notes for the same extension INF. In the first, describe an initial submission and identify the need for a newly generated ExtensionID. In the second, describe an update to the published extension and retain the ExtensionID while changing the DriverVer version and/or date. Then state which part of the process concerns lineage and which part concerns ranking.
How SetupAPI access fits the exam topic
Study SetupAPI access as the programmatic inspection layer for INF files. A device-installation application first opens an INF, optionally appends another INF, retrieves information or paths, and finally closes the handle when it no longer needs the file.
The documented sequence begins with SetupOpenInfFile, which returns a handle. If the application does not know the filename, SetupGetInfFileList can list INF files in a directory. SetupOpenAppendInfFile can append another INF to the opened file; if no filename is supplied, the LayoutFile entry from the opened INF’s INF Version section determines the appended file.
When access is complete, SetupCloseInfFile releases resources allocated by SetupOpenInfFile. This lifecycle is worth practicing because it tests operational understanding rather than recognition of a single function name.
For information retrieval, SetupGetInfInformation, SetupQueryInfFileInformation, and SetupQueryInfVersionInformation retrieve information about an INF. SetupGetSourceInfo and SetupGetTargetPath obtain source-file and target-directory information. SetupGetLineText and SetupGetStringField provide direct line- or field-level access when an application needs to inspect stored values.
Do not confuse direct parsing with the higher-level SetupAPI functions. The documented line- and field-level functions are used internally by higher-level SetupAPI functions but remain available when an application must access that detail. A useful study task is to map each function to its phase: discover, open, append, query, inspect, or close.
A troubleshooting workflow
Given an installation issue, first identify the INF and the device identifier involved. Next inspect the relevant Manufacturer and Models route, confirm the platform decoration, trace the referenced DDInstall section, and then inspect files, registry operations, WDF sections, or component references. If a tool is involved, decide whether it needs file-level, line-level, version, source, or target-path information before choosing a SetupAPI function.
What to build in a hands-on lab
A small, controlled lab is more useful than passive rereading because INF behavior depends on relationships among sections, identifiers, architectures, and framework directives. Keep experiments isolated, document the expected route before installation, and use only your own packages or Microsoft documentation examples rather than attempting to reproduce live exam content.
Create a minimal package map with Manufacturer, Models, and DDInstall relationships. Add a hardware ID and a compatible ID, then explain which device each entry is intended to match. Extend the exercise with platform-decorated Models and install sections, checking that the target architecture is explicit.
Create separate KMDF and UMDF notes or samples. For UMDF, include a service reference and service-install section; for KMDF, include the corresponding KMDF relationship. Use framework-version variables where the documentation recommends them, and annotate which values are supplied by the build process.
Create a component-INF scenario in which an optional software module is installed as a virtual child device. Record the parent-start dependency and the independent servicing rationale. Then compare a Type 1 AddSoftware use case with a Type 2 case without treating the two directives as interchangeable.
Finally, write a small inspection plan using SetupAPI concepts. The plan should identify how an application would locate an INF, open it, append another file if needed, query version or path information, access a specific field, and close the file. The plan can be pseudocode; the learning objective is selecting the right operation and explaining its place in the lifecycle.
How to judge whether the lab is working
A successful lab result is not simply that a file installs. You should be able to predict the selected section, explain the identifier that enabled the match, identify the architecture or operating-system decoration in play, and locate the WDF or component relationship that controls the next installation step. If you cannot explain the route, return to the section map before adding complexity.
A practical four-stage study roadmap
Use a staged plan that moves from syntax recognition to design judgment. Because the supplied research contains no official exam duration, question count, scoring model, or domain weighting, set stages by demonstrated capability rather than by assumed percentages or a fixed number of days.
Stage one is vocabulary and structure. Learn what an INF does, how INX variables are replaced, and how Manufacturer, Models, hardware IDs, compatible IDs, and DDInstall sections connect. Produce a one-page relationship diagram and explain it aloud without reading from the documentation.
Stage two is targeting and framework configuration. Practice platform extensions and historical scope carefully, then compare KMDF and UMDF section structures. Add the UMDF USB version distinction to your notes, keeping the 2.15 boundary attached to the NativeUSB and WinUsb choices. Finish this stage by diagnosing deliberately broken section names or missing references in a private sample.
Stage three is packaging and servicing. Work through component INF design, SoftwareComponent setup class requirements, AddComponent, AddSoftware Type 1 and Type 2, parent-device startup, and independent child updates. Then study extension-INF lineage, DriverVer comparison, base-driver updates, and separate package submissions.
Stage four is timed decision practice, if your programme provides a time limit. Use your own scenario prompts and Microsoft documentation. For each answer, write the rule, the evidence, the condition that limits it, and the reason an alternative is wrong. Review errors by concept, such as matching, decoration, WDF, component packaging, extension servicing, or SetupAPI lifecycle.
At the end of the roadmap, do not ask only whether you recognize directive names. Ask whether you can select a section, identifier, package boundary, or API operation and justify that selection from the documented behavior.
Suggested study order when time is limited
Prioritize INF purpose and section flow first, then Models matching and platform decorations. Study WDF directives next because they depend on understanding DDInstall relationships. Follow with component and extension INF servicing, and finish with SetupAPI access. This order reduces the chance of memorizing advanced directives without understanding where Windows uses them.
Mistakes that make preparation look stronger than it is
The most dangerous preparation mistakes are confident assumptions: treating a guessed blueprint as official, memorizing directives without their section context, and using one platform rule for every Windows generation. Correct these by attaching every note to a condition, section, or lifecycle event.
Do not invent exam logistics from third-party listings. The supplied sources do not verify delivery method, test location, duration, languages, prerequisites, price, passing score, question count, or scheduling windows for INF-203x. Confirm those items through the current official certification or testing information before paying or booking.
Do not study bare percentages. No blueprint weights were provided, so there are no supported percentages to reproduce or compare. Use the topic sequence in this guide only as a practical study priority, not as evidence that one area carries more marks than another.
Do not treat an ExtensionID as an applicability filter. The supplied Microsoft guidance explicitly separates lineage and versioning identification from applicability. Similarly, do not assume changing an extension’s identity is the normal way to publish an update; a published extension update retains its ExtensionID while its DriverVer version and/or date is incremented.
Do not put every optional feature into the base driver package. First decide whether the feature is required for core functionality and whether independent servicing matters. Component INF guidance exists precisely because optional device software may need a separate package and virtual child-device relationship.
Do not confuse a compatible ID with a guarantee that any device is safe to install. The Models entry indicates compatibility under the same driver; it does not replace careful device support, platform targeting, or package validation.
Do not write a WDF answer that omits the section relationship. Saying only “use KMDF” or “use UMDF” does not show whether the candidate understands DDInstall.wdf, the referenced service-install section, framework version directives, or model-specific policy settings.
Do not rely on memorized dumps or leaked material. Unauthorized questions are not a substitute for understanding, may be inaccurate, and cannot establish that you can reason about an unfamiliar INF scenario. Build your own prompts from the official documentation instead.
A quick self-audit
You are not ready to schedule until you can explain an INF’s purpose, trace a Models entry to DDInstall, choose and justify a platform decoration, distinguish KMDF from UMDF installation sections, describe when a component INF is appropriate, preserve ExtensionID lineage during an update, and place SetupAPI functions in the correct access lifecycle.
What to verify before scheduling INF-203x
Scheduling should be a separate decision from technical readiness. The supplied official research explains Windows driver installation but does not identify the INF-203x registration authority or publish current exam-administration rules, so verify the live programme page before committing money or time.
Confirm the exact exam title and current status first. Then check the authoritative registration route for prerequisites, delivery options, permitted languages, identification rules, rescheduling or cancellation terms, fees, duration, scoring, and any available objective document. None of those details should be inferred from the Microsoft INF references.
Check whether the official programme publishes a skills outline or blueprint. If it does, compare that document with your study map and adjust priorities. If the official outline uses domains or percentages, keep each percentage attached to its named domain; do not transfer weights from another exam or from a third-party practice site.
Schedule only after your evidence review is stable. Your readiness evidence should include a completed section-flow exercise, a platform-targeting exercise, a WDF comparison, a component or extension-INF design explanation, and a SetupAPI inspection workflow. These outputs are more meaningful than a high score on unverified material.
Before the appointment, make a short list of terms that remain conditional: framework versions, platform suffixes, ExtensionID versus DriverVer, AddSoftware types, and parent-device startup. Review the current Microsoft pages and the official exam instructions for those terms rather than relying on an old personal summary.
Where the technical evidence comes from
Use Microsoft Learn as the technical reference set for this guide: INF overview, Models sections, cross-platform INF creation, component INFs, WDF directives, extension INF submission, x64 display-driver information, and SetupAPI access. The links are collected below so you can revisit the primary material while checking any current exam-specific publication separately.
Your next actions after reading
Turn this guide into an evidence log rather than another document to reread. Record each topic, the Microsoft page that supports it, the condition or section involved, and one explanation you can produce without copying the wording.
First, draw the INF installation route from Manufacturer and Models through the relevant DDInstall and any WDF or component sections. Second, create a platform-decoration comparison and explain the non-x86 requirement described for Windows Server 2003 SP1 and later. Third, write the UMDF 2.15 USB comparison with its conditions intact.
Next, produce two short design memos: one for separating optional software into a component INF, and one for updating a published extension INF while preserving ExtensionID lineage. Finish with a SetupAPI lifecycle diagram from discovery and opening through querying and closing.
Finally, locate the current official INF-203x exam page and fill the logistics gaps that this research cannot verify. If the official objectives differ from the supplied technical scope, follow the current official objectives and use this article as supporting Windows driver-installation study material rather than as a substitute for the official exam specification.
Conclusion
The strongest INF-203x preparation is conditional and traceable. Learn how identifiers select Models entries, how decorated sections target platforms, how DDInstall connects to WDF configuration, how component and extension INFs separate servicing concerns, and how SetupAPI applications inspect package data. Keep those technical rules distinct from unverified exam logistics. Once you can justify each decision with the relevant Microsoft documentation and have confirmed the current official scheduling information, you can choose a study endpoint and booking date on evidence rather than assumption.
Related exams
- 77-725 exam — Microsoft Word 2016 Core: Document Creation, Collaboration and Communication (MOS)
- 77-727 exam — Excel 2016: Core Data Analysis, Manipulation, and Presentation
- 77-728 exam — Excel 2016 Expert: Interpreting Data for Insights
- 77-731 exam — Outlook 2016: Core Communication, Collaboration and Email Skills
- AZ-120 exam — Planning and Administering Microsoft Azure for SAP Workloads
- AZ-400 exam — Microsoft Azure DevOps Solutions
