Post

JNUC 2026: Automating Third-Party Patching with App Auto-Patch and Jamf

Andrew Spokes and I returned to JNUC to talk about App Auto-Patch: the script-based version 3 workflow, background staging and patching, and a first look at the native version 4 app.

JNUC 2026: Automating Third-Party Patching with App Auto-Patch and Jamf

JNUC 2026 logo

At JNUC 2026, Andrew Spokes and I presented Automating Third-Party Patching with App Auto-Patch and Jamf. We covered the ongoing application-patching workflow, the controls available to administrators, and what users actually see when updates are waiting.

We also unveiled App Auto-Patch 4, giving attendees a first look at the project’s move to a native Mac app.

Watch our JNUC 2026 session on YouTube.

One important distinction before diving in: most of this session covers the script-based 3.x workflow, including capabilities discussed for version 3.6 and later. The native version 4 demonstration comes toward the end. If you are deploying the current release, use appautopatch.app for today’s instructions rather than assuming every setting or deployment step in the recording is unchanged.

The problem is still the work around patching

Updating one application is rarely the difficult part. The ongoing work is knowing which applications are installed, identifying updates, arranging when they can install, and following up when someone cannot stop working right now.

App Auto-Patch brings those responsibilities together. It orchestrates discovery, scheduling, deferrals, and installation without requiring admins to maintain a separate deployment workflow for every supported application.

In the 3.x workflow we presented, three components work together:

  • Installomator provides application-specific discovery and installation logic through its community-maintained labels.
  • swiftDialog supplies the user-facing progress and deferral experience.
  • A LaunchDaemon keeps the workflow moving after initial deployment, rather than requiring a recurring MDM policy to start every run.

That separation is useful: App Auto-Patch coordinates when work should happen, while Installomator handles the application-specific update work.

Discovery, deferrals, and installation

The session walks through the workflow in three phases.

First, discovery compares installed applications with Installomator labels and checks for available updates. The resulting queue is shaped by the labels and rules the administrator has configured.

Next comes the decision about when updates should happen. Where deferrals are enabled, the user can review the applications that need attention and choose an allowed deferral period or proceed with installation.

Finally, queued applications are handed to Installomator. The interactive workflow gives users progress feedback rather than leaving them to guess whether an update is still working.

The label categories are another important boundary. Ignored, required, optional, and excluded-background labels let admins decide what AAP should manage and which applications should not be patched silently. The right choices depend on what other management tools already own.

Stage first, interrupt less

One of the areas we covered for version 3.6 and later was background staging and patching.

Downloading an installer before the final update step can reduce the wait at the point where the user is ready to proceed. Closed applications can be updated silently in the background when that behavior is configured; open applications are handled through the user-facing workflow.

The practical benefit is not simply fewer dialogs. It is reserving user interaction for the work that actually needs the user’s attention. Application selection, running-process behavior, and deadline enforcement still need to be tested together.

Scheduling is more than “run once a week”

We also spent time separating the events that make up a patch cycle:

  • When discovery should run.
  • Where the current patch cycle begins.
  • How long or how many times users can defer.
  • When updates become required.
  • When completion and deferral state reset for the next cycle.

Those decisions are related, but they are not the same setting.

In the script-based workflow, a managed configuration profile takes precedence over local configuration, while command-line triggers provide another way to launch or configure supported behavior. After deployment, the background agent can manage its schedule without holding up the Jamf binary for every subsequent run.

The recording also shows the three interaction modes: completely silent, silent discovery with interactive patching, and fully interactive. That lets admins choose the amount of visibility that fits their environment instead of assuming one experience works for everyone.

The version 4 reveal

At the end of the session, we moved from the script-based workflow into the next direction for App Auto-Patch: a native application built with SwiftUI.

The demonstration introduced the dashboard and menu bar experience, per-application update visibility and history, and troubleshooting within the app. The architectural shift also separates the user-facing application from a privileged helper that performs installation work.

The intention is to make patching an understandable, ongoing experience, not just a process users encounter when a dialog appears.

That reveal is a useful bridge from the earlier articles on this blog. It is also worth distinguishing the demonstration from the current release: the app and its documentation have continued to evolve.

Where to go now

If you are new to App Auto-Patch, the recording explains the problems behind the workflow and how the pieces fit together. If you already use the script-based release, it provides context for the native app’s direction without replacing the current upgrade instructions.

For a deployment today:

That helper belongs to today’s configuration workflow; the recording remains a look at the workflow and version 4 preview we presented at JNUC.

Thanks to Andrew for co-presenting and for his work on App Auto-Patch, and to the contributors behind App Auto-Patch, Installomator, and swiftDialog. These projects benefit from admins sharing real deployment experience and helping improve the tools for everyone.

This post is licensed under CC BY 4.0 by the author.