How to Become a Desktop Engineer — Part 9: App Packaging & Patching
How to Become a Desktop Engineer — Part 9 of 13
App Packaging & Patching
Post 8 gave you the platforms — Intune, ConfigMgr, and the bridge between them. This is the ninth post in a thirteen-part series on how to become a desktop engineer, and it's the work those platforms exist to do: turning software into packages that deploy cleanly, and keeping the whole fleet patched without breaking it. A package that fails lands on five hundred desks at once, and a patch that breaks a business app gets a phone call from a vice president.
The postings name it directly. McLaren, Ingram and Frier Levitt all list application packaging and patching as headline duties, and Dairy Farmers deploys "updates and applications through Windows Update for Business, Patch My PC, and Intune."
Packaging from first principles
An installer is a script with a fancy coat on: copy these files, write these registry keys, create these shortcuts — and, if anything goes wrong, put it all back. A package is that installer made deployable: silent, predictable, and provable.
The three formats you'll meet:
MSI is the old standard, and still the most common in the enterprise. A Windows Installer package is a database: it declares exactly what it installs, so Windows can repair, upgrade or remove it cleanly. If the vendor ships an MSI, start there.
EXE is everything else — a setup program that can do anything, including things you can't see. Most are custom code with their own silent switches and their own exit codes. The work with an EXE is finding its silent install switch — usually /S, /quiet or /silent, always in the vendor's documentation or a packaging forum — and proving the exit code actually means success. An EXE that returns 0 and didn't install anything is a trap you'll meet at least once.
MSIX is Microsoft's modern format: a containerised package that installs cleanly, updates atomically and uninstalls without leaving debris. It's the best-behaved of the three — and the least available. Most vendors still ship MSI or EXE, and repackaging their installer into MSIX is a project, not a checkbox. Prefer it when the vendor offers it.
Why a package that "works on my machine" fails on five hundred: because your machine isn't the fleet. It has the dependency already installed, the admin rights the user won't have, the 32-bit path on a 64-bit machine. Packaging is the discipline of removing your machine from the equation: install it on a clean VM that looks like the standard build, as SYSTEM, with no user logged on, and watch what it actually does.
Win32 apps in Intune

In Intune, a Win32 app is a package wrapped in Microsoft's format. The IntuneWinAppUtil wraps your installer and its files into a single .intunewin file, and you upload that to Intune with four things attached: the install command, the uninstall command, the requirements, and the detection rule.
The detection rule is the whole job. Intune doesn't watch your installer run — it runs the command, then checks the rule to decide whether the app is there. A rule that says "this MSI product code exists" or "this file exists at this path with this version" is a fact. A rule that says "this folder exists" is a hope: the folder exists the moment the installer creates it, even if the install failed halfway. Every "the app says installed but it isn't" ticket you've ever heard about is a detection rule that lied. Write the rule to prove the app works, not to prove the installer ran.
The install command runs as SYSTEM by default — no user profile, no desktop, no "click Next." And the uninstall command matters as much as the install: the day a vendor ships a broken update, the uninstall command is how you pull it back off five hundred machines before lunch. Test it on one machine before you need it on five hundred.
PSADT: the standard wrapper
Some installs need more than a silent switch: close the app before updating it, tell the user a restart is coming, let them defer until after the meeting, clean up the old version properly. That's what the PowerShell App Deployment Toolkit is for — PSADT is the wrapper packaging specialists reach for when the installer alone isn't enough.
It's a free, open-source PowerShell toolkit, and the current line is v4: a code-signed module, rebuilt from the ground up, that still runs your old v3 deployment scripts unchanged. It's maintained under Patch My PC's stewardship — the project stays open-source and free — and the current stable release is v4.1.8 (January 2026), with v4.2.0 in release-candidate testing (October 2026). A PSADT package gives you the user-facing parts for free: a branded close-apps prompt, a deferral button with a deadline, a countdown to a forced restart — and the logging to prove what happened on every machine. The install is the easy part. The user experience around the install is the job.
Patching as a discipline

Patching is packaging on a schedule, and it has the same rule: never let the fleet be the test.
Update rings are the mechanism. A ring is a group of devices with a schedule: how long after release a quality update installs, how long a feature update waits, how many days before the deadline forces the restart. The pilot ring is IT — your own team, the machines you can walk to. Then a small early ring, five or ten percent, chosen to look like the fleet: a few of each model and department, one awkward edge case. Then broad, then production. The gap between rings is the safety net: a driver that breaks one model shows up in the pilot, not in the finance department on month-end.
Windows Update for Business is the native engine: the rings, deferrals, deadlines and grace periods, all driven by Intune policy. Windows Autopatch is Microsoft running the rings for you — same engine, Microsoft-managed groups and cadence. Hotpatch applies security updates without a reboot on the editions that support it, which turns the monthly "restart tonight" negotiation into a non-event.
And then there's everything Microsoft doesn't patch: Adobe, Chrome, Zoom, the line-of-business app the vendor updates twice a year. Third-party patching closes that gap — tools like Patch My PC integrate natively with Intune and Configuration Manager and cover more than a thousand applications, publishing third-party updates through the same rings and the same reporting as Microsoft's own. A fleet patched for Windows and unpatched for everything else has a hole in it; that catalogue is how you close it.
The safety net
A bad package ships to the whole fleet at exactly the same speed as a good one. That's why the safety net is a discipline, not a tool.
Pilot everything. Every package, every update, goes to the pilot ring first and stays there for a full cycle — not an afternoon. A package that looks fine on day one can break on day fourteen, when the app phones home for its licence check.
Test the detection rule, not the install. Deploy to a test machine, uninstall, deploy again, and check the rule tells the truth in both directions. A rule that says "installed" when the app is gone will haunt you at audit time.
Have the rollback ready before you deploy. Know the uninstall command and the previous version's package. The engineer who can pull a bad update in an hour is calm in the meeting. The one who can't is the meeting.
And document it — package version, detection rule, pilot results, the date it went broad — because six months from now, the notes are the difference between a ten-minute fix and a ten-hour investigation.
Practise it this week
- Wrap a real app. Take a free app with a messy EXE installer, find its silent switch, wrap it with the IntuneWinAppUtil, and write a detection rule that proves the app works. Deploy it to a test VM as SYSTEM, then uninstall it with your own uninstall command.
- Give it a user experience. Rebuild the same package inside PSADT: a close-apps prompt, a deferral with a deadline, a restart countdown. Install it while a document is open and watch what the user sees.
- Draw your rings. Design a four-ring update plan for a thousand-device fleet: who is in each ring, how long each ring waits, and what you do when the pilot ring reports a failure.
Next up: PowerShell Deep Dive. Packaging and patching are the what — PowerShell is the how. The one skill every posting names, from the one-liner that answers a ticket to the script that runs the fleet.
Missed the earlier posts? Start with Part 1: What a Desktop Engineer Actually Does, Part 2: The Path, Stage by Stage, Part 3: The Mindset — Curiosity Is a Technical Skill, Part 4: Windows 11 Inside Out, Part 5: Identity: AD, GPO, Entra ID, Conditional Access, Part 6: Networking Essentials, Part 7: Intune + Autopilot, and Part 8: SCCM & Co-management.



















