The Curious Case of the Incomplete SCCM Request

It was another Monday morning, and you’d barely settled into your chair when the email popped up: “Hey, can you automate the install of [Insert Application of the Week]? Thanks!”

Simple enough, right? Except experience told you that “simple” was a trap. Behind every “simple install” lurked unspoken dependencies, forgotten configurations, and that one obscure setting buried in a 200-page admin guide. This time, though, you were ready. You’d developed a system—a foolproof way to gather all the prerequisites and turn chaos into a smooth, automated masterpiece.

Here’s how you do it.

Start With a Gentle Interrogation

Your first move? Respond to the request with some polite but pointed questions. You’re not grilling a suspect—you’re just… clarifying.

• What exactly do you want this to do?
  Is the goal to install the app and call it a day, or are there follow-ups like configurations, license activations, or mysterious registry keys?
• What does “working” look like to you?
  Is it just sitting there quietly installed, or does it need to hum a specific tune on startup?
• What could go wrong?
  If you’ve ever been told, “It works fine on the test machine,” you know this question is worth its weight in log files.

Asking the right questions upfront saves you from playing a game of “Who Broke It?” later.

Gather the Sacred Prerequisites

Every automation project has its holy relics—those bits of information and tools you must collect before starting your quest.

1. The Installer
   Is it an MSI, an EXE, or something rarer, like a proprietary installer with no silent mode (cue dramatic sigh)? If it's an MSI, confirm the silent install switches (/quiet /norestart) and any custom properties.

2. Dependencies
   Does this app need .NET, Java, or the collective hopes and dreams of the IT department? Make a list. Don’t forget drivers, libraries, or network permissions.

3. Configuration Settings
   Are there configuration files to edit? Registry keys to add? Licensing servers to point to? Clarify if these need to be machine-wide or user-specific.

4. Testing Criteria
   How will you verify the installation? Write a script or a test plan. Even a basic "open the app and poke at it" plan is better than crossing your fingers.

5. Rollback Plan
   No one likes to think about failure, but it’s better to plan for it than to discover mid-install that your only rollback strategy is "unplug the computer and pray."

Beyond MSI: Tackling Configurations

Let’s say the install is only part of the job. Maybe the app needs some post-install TLC:

• Configuration Files: You can automate edits to .INI, .JSON, or XML files with PowerShell.
• Registry Keys: A little Set-ItemProperty action in PowerShell works wonders.
• Service Connections: Does the app need to talk to a server or database? If yes, automate the setup and test the connection.

The key here is modularity. Each step should work on its own, like a Lego block. If the post-install fails, the install itself should remain intact.

The Magic of Application Groups

Now, what if you need to install not one but several applications, each with its quirks and dependencies? Enter SCCM application groups, the Swiss Army knife of multi-app deployments.

With application groups, you can:

• Maintain Order: Specify the install sequence to avoid, say, installing the app before its dependencies.
• Keep It Modular: Each application can have its detection methods and install/uninstall scripts.
• Make Updates Easy: Need to tweak one component? No problem—you can update it without redoing the whole group.

For example, automating a developer workstation setup might include:

1. Installing Visual Studio.
2. Configuring Git.
3. Setting up Node.js.
4. Running a custom PowerShell script to pull environment settings.

Each step is managed individually but deployed as a seamless package. Efficiency and control? Check and check.

The PowerShell Angle

PowerShell is your best friend here. Let’s break it down:

1. Pre-Checks: Before you do anything, make sure the system is ready. Check for disk space, existing dependencies, or incompatible versions.

   if ((Get-Volume -DriveLetter C).SizeRemaining -lt 10GB) {
       Write-Error "Not enough disk space!"
       exit
   }
   

2. Silent Installation: Automate the install with Start-Process or SCCM cmdlets.

   Start-Process "msiexec.exe" -ArgumentList "/i MyApp.msi /quiet /norestart" -Wait
   

3. Post-Install Tasks: Add configurations, apply registry keys, or start services.

   Set-ItemProperty -Path "HKLM:\Software\MyApp" -Name "ConfigKey" -Value "ConfigValue"
   

4. Validation: Always test. Whether it’s as simple as checking for a file or as complex as running a test script, make sure you verify success.

The Final Word

Automation isn’t just about making life easier (though it definitely does that). It’s about creating robust, repeatable processes that reduce errors and free you to tackle more exciting challenges. By asking the right questions, gathering prerequisites, and embracing tools like PowerShell and SCCM application groups, you’ll deliver solutions that go beyond "just works" to "works beautifully."

And the next time someone asks for a “simple install,” you’ll smile, knowing you’re already three steps ahead.