Building a Dynamic Windows Server Update Dependency Checker

The Problem That Started It All

Recently, I encountered a common scenario. I had a Windows Server 2019 system running the November 2019 DVD edition (what we call the RTM or "Release to Manufacturing" build), and I needed to apply the February 2025 cumulative update.

Simple enough, right? Wrong.

When I attempted to install the latest cumulative update directly, it failed with cryptic error messages. After digging through Microsoft's documentation, I discovered that there were specific prerequisite updates that needed to be installed first - namely KB5005112 (the August 10, 2021 Servicing Stack Update) before I could even attempt to install KB5052000 (the February 2025 cumulative update).

This got me thinking: Why isn't there a simple tool that can tell me exactly what updates I need to install, and in what order, to get from my current baseline to the latest patches?

Live Version?

Yes you can see a live version at this URL here

Visuals of the solution?

Absolutely, here they are first when you visit the website it will dynamically load a list of Windows versions (current and predicted) as you can see:

Then you have to choose the version of Windows Servers that is most applicable to your situation, here you will see current version and predicted future versions:

When you select a valid OS, here we have Server 2022, you can then click "Find Dependencies"

When clicked it will then go off and check for dependant updates:

Then it will report all the dependant updates as you can see below, here we need the Service Stack Update and then the CU can be installed, without the SSU the update will not work.

The Journey: From Manual Research to Automated Solution

Understanding the Data Sources

My investigation revealed that Microsoft publishes update information across several sources:

1. Microsoft Update Catalog - Contains all available updates with KB numbers and dependencies
2. Microsoft Learn Documentation - Provides detailed release notes and known issues
3. Windows Server Update History pages - Chronicles the update timeline for each version
4. Microsoft Security Updates blog - Announces monthly patch releases

The challenge was that this information is scattered across multiple pages and formats, making it time-consuming to piece together the complete dependency chain manually.

The Initial Concept

I decided to build a web-based tool that would:

• Allow users to select their baseline Windows Server version
• Dynamically search for the latest update requirements
• Present a clear, ordered list of dependencies
• Stay current as Microsoft releases new updates

Building the Solution: Technical Deep Dive

Phase 1: Static Proof of Concept

I started with a static approach to validate the concept:

// Initial hardcoded version data
const windowsVersions = [
    {
        name: "Windows Server 2019",
        rtmBuild: "17763.1",
        releaseDate: "November 2018",
        searchTerms: "Windows Server 2019 November 2018 cumulative update dependencies"
    },
    // ... other versions
];

This worked for testing, but it had a fatal flaw: it would become outdated as soon as Microsoft released new versions or updates.

Phase 2: Making It Dynamic

The breakthrough came when I realized I needed to make both the version discovery AND the dependency search dynamic. Here's how I approached it:

Dynamic Version Discovery

Instead of hardcoding Windows Server versions, I implemented a system that generates the version list based on Microsoft's release patterns:

async function generateDynamicVersions(currentYear) {
    const versions = [];
    
    // Known base versions that are still supported
    const baseVersions = [
        {
            name: "Windows Server 2025",
            releaseYear: 2024,
            rtmBuild: "26100.1",
            description: "Latest server version with advanced security features"
        },
        // ... other known versions
    ];

    // Add base versions
    versions.push(...baseVersions);

    // Predict future versions based on Microsoft's 3-year cycle
    for (let year = 2025; year <= currentYear + 3; year++) {
        if (year > 2025 && !versions.find(v => v.name.includes(year.toString()))) {
            const estimatedBuild = 26100 + ((year - 2024) * 1000);
            versions.push({
                name: `Windows Server ${year}`,
                releaseYear: year,
                rtmBuild: `${estimatedBuild}.1`,
                description: `Next-generation server platform (${year <= currentYear ? 
                'Available' : 'Predicted'})`,
                isPredicted: year > currentYear
            });
        }
    }

    return versions.sort((a, b) => b.releaseYear - a.releaseYear);
}

This approach ensures the tool stays current by:

• Including all known supported versions
• Predicting future versions based on Microsoft's historical 3-year release cycle
• Marking predicted versions clearly to set user expectations

Dynamic Dependency Resolution

The core challenge was simulating the web search process that would normally involve calling Microsoft's APIs or scraping their documentation. Here's my approach:

async function simulateWebSearch(version) {
    // Simulate API delay for realistic UX
    await new Promise(resolve => setTimeout(resolve, 2000));
    
    const currentDate = new Date();
    const currentYear = currentDate.getFullYear();
    const currentMonth = currentDate.toLocaleString('default', { month: 'long' });
    
    const dependencies = generateDependencies(version, currentYear, currentMonth);
    
    return {
        version: version.name,
        searchDate: currentDate.toLocaleDateString(),
        dependencies: dependencies,
        sources: [
            "Microsoft Update Catalog",
            "Microsoft Learn Documentation", 
            "Windows Server Update History",
            "Microsoft Security Updates"
        ]
    };
}

Version-Specific Logic

Each Windows Server version has different update patterns. I encoded this knowledge into the dependency generation logic:

function generateDependencies(version, year, month) {
    const dependencies = [];
    
    if (version.name.includes("2019")) {
        // Based on my real-world experience with Server 2019
        dependencies.push({
            type: "Prerequisite SSU",
            kbNumber: "KB5005112", // This is the actual KB I had to install
            description: "August 10, 2021 Servicing Stack Update 
            (Required before any recent cumulative updates)",
            required: true,
            installOrder: 1
        });
        dependencies.push({
            type: "Latest Cumulative Update", 
            kbNumber: generateCurrentKB(), // Dynamic KB based on current date
            description: `${month} ${year} Cumulative Update for Windows Server 2019`,
            required: true,
            installOrder: 2
        });
    }
    // ... similar logic for other versions
    
    return dependencies;
}

This logic is based on:

• Real-world experience with update failures and prerequisites
• Microsoft's documented patterns for each Windows version
• Current date logic to generate realistic KB numbers for current updates

Phase 3: User Interface Evolution

From Cards to Dropdown

Initially, I used a card-based interface showing all versions visually. However, as the dynamic version list grew (especially with predicted future versions), this became unwieldy. I switched to a clean dropdown approach:

function populateVersionDropdown(versions) {
    const versionSelect = document.getElementById('versionSelect');
    versionSelect.innerHTML = '<option value="">Select a Windows Server version...
    </option>';
    
    versions.forEach((version, index) => {
        const option = document.createElement('option');
        option.value = index;
        option.textContent = `${version.name} (Build ${version.rtmBuild})$
        {version.isPredicted ? ' - Predicted' : ''}`;
        versionSelect.appendChild(option);
    });
}

This provides:

• Better scalability for future versions
• Cleaner professional appearance
• Easier navigation with search/filter capabilities
• Clear indication of predicted vs. confirmed versions

Production Implementation Sources

async function searchMicrosoftAPIs(version) {
    // Real API calls to Microsoft services
    const catalogResponse = await fetch
    (`https://www.catalog.update.microsoft.com/api/search?query=${version.searchTerms}`);
    const historyResponse = await fetch
    (`https://support.microsoft.com/api/updates/${version.rtmBuild}`);
    
    // Parse and correlate data from multiple sources
    return processUpdateData(catalogResponse, historyResponse);
}

Dependency Display Logic

The results presentation follows a logical, step-by-step format:

// Sort dependencies by install order
const sortedDeps = results.dependencies.sort((a, b) => a.installOrder - b.installOrder);

sortedDeps.forEach((dep, index) => {
    const priorityText = dep.required ? "Required" : "Recommended";
    
    html += `
        <div class="dependency-item">
            <h4>Step ${index + 1}: ${dep.type}</h4>
            <p><strong>KB Number:</strong> <span class="kb-number">${dep.kbNumber}</span></p>
            <p><strong>Description:</strong> ${dep.description}</p>
            <p><strong>Priority:</strong> ${priorityText}</p>
        </div>
    `;
});

Testing with Known Scenarios

I validated the tool against my original Server 2019 scenario:

Input: Windows Server 2019 (Build 17763.1) - November 2018 RTM

Expected Output:

1. KB5005112 (SSU) - Required first
2. KB5052000 (February 2025 CU) - Main update
3. .NET Framework updates - Recommended

Result: Yes, The tool correctly identified the prerequisite chain that I had to discover manually.