Installing a single application may seem like a straightforward process, but installing the same app on hundreds of devices is far more complicated. Every app must be prepared to install the same way on every device without prompts or interrupting users.
Enter application packaging, where you prepare a software installer so you can deploy it across an organization’s devices. Organizations often deploy apps with tools like Microsoft Intune and SCCM, but each app has to be packaged before those tools can deliver it, so it’s important to know what packaging entails and how it works.
With that in mind, let’s explore application packaging: what goes into a package, how it works, and the challenges it may face.
What is application packaging?
Application packaging is the process of preparing a software installer so it can be deployed across multiple devices without requiring user interaction. A package includes the installer plus the commands to install it silently and uninstall it if necessary, any settings or customizations, and a way to confirm the installation succeeded.
With proper application packaging, every connected device receives the same app version and configuration, without a user at the keyboard to manually configure and approve everything on each device. This ensures a consistent experience across the company while saving time and improving efficiency. For example, IT might package a PDF reader so it installs silently on every laptop with automatic updates turned off and the company’s default settings applied.
What goes into an application package
Application packaging contains a few elements that help ensure a consistent deployment across devices. This includes:
1. The installer
This is the vendor’s setup file, usually in an MSI or EXE installer format. While MSI installers follow a standard set of command-line options, EXE installers can vary by vendor, so they may require more research to package properly. For the exact commands, see our guides to MSI silent installs and EXE silent installs.
2. Silent install and uninstall commands
One key capability of an application package is installing and uninstalling apps without prompting users or interrupting work. Silent install and uninstall commands are command-line switches that run the installer without prompting and remove it cleanly, so the package can run unattended.
3. Install logic and customizations
Companies often have specific rules and settings for their applications. The install logic and customization scripts can run the installation and apply the settings, such as adding license keys or turning automatic updates on or off. IT teams often use wrappers like the PowerShell App Deployment Toolkit (PSADT) to control what users see, such as prompts or reminders to restart after installation.
4. A detection rule
You don’t want to install the same application repeatedly. A detection rule checks whether an app is already installed, for example by checking file versions, registry keys, or MSI product code. Without a good detection rule, users can encounter unnecessary reinstalls or false failures.
5. The deployment format
Not all apps are deployed the same way. For instance, Microsoft Intune Win32 apps must be prepared with the Microsoft Win32 Content Prep Tool, which converts the installation files into the .intunewin format Intune accepts. SCCM uses its own application model, and Windows also has the newer MSIX package format. Using the right format is necessary for successful installations.
How to package an application
Packaging an application isn’t as simple as grabbing a few files and throwing them in a folder. Packages have specific requirements and rules they must include, so following these steps is necessary:
Gather requirements: First, you’ll need to know what your package requires. Check which version of the app you need, who needs it, any license keys, the required settings, and any other prerequisites.
Get the installer and research it: Next, download the installer from the vendor and inspect it. You’ll want to identify its type, then find its silent install and uninstall switches (either in the vendor documentation or by testing).
Build the install logic: Proper install logic helps ensure everything deploys correctly. Write the install and uninstall script, apply customizations, and set how users are notified and whether they can defer, so all your guidelines are in place.
Create the detection rule: Detection is important for verifying installations and avoiding unnecessary reattempts. Set a rule for how the deployment tool will confirm the app is installed, such as by file version, registry key, or MSI product code.
Test before deployment: Testing is vital to ensure everything works as intended and catch issues before they impact users. Install, verify, and uninstall the package on a clean test machine to make sure it can be added and removed properly. App compatibility testing is also important for ensuring it doesn't conflict with the applications you already use.
Prepare it for your deployment tool: If everything checks out, then you can prepare the packaging for deployment. Convert the package to the deployment tool's format, such as an .intunewin file for Intune, and enter the app details.
Pilot, then roll out: Finally, it’s time to deploy the package. Start with a small group of devices to check results and identify issues, then expand to larger groups if everything checks out.
When a new update comes out, you’ll need to repeat steps 2 through 7 to roll it out across devices.
Application packaging vs repackaging vs deployment
We also need to understand the difference between packaging and repackaging, and how both differ from app deployment. While they may seem synonymous at first glance, there are some key differences that matter for application rollouts.
Packaging
Application packaging prepares the vendor’s installer to run silently across devices and within your settings. This usually involves using a script to ensure it rolls out according to the organization’s rules, but the vendor’s installer still does the actual installation.
Repackaging
With repackaging, the organization captures the changes an installer makes to a test machine, such as files and registry entries, and rebuilds them in a new installer. This is used when an installer can't be run silently or customized any other way. However, many teams prefer using the original installer and wrapping it in a script rather than repackaging it, since that's easier to maintain across updates.
Deployment
Deployment occurs after the app has been packaged. This uses a tool like Intune or SCCM to roll the application out across all the connected devices. The deployment process also includes choosing which devices receive the app, the order they receive it in, and when updates roll out, as well as tracking installation to ensure everything completes successfully. In short, packaging prepares the app, while deployment delivers it to the devices that need it.
Why application packaging is hard to keep up with
While application packaging is vital, it can also be a challenge to keep up with. When businesses deploy multiple apps and updates across large endpoint environments, it’s easy to fall behind, which can leave critical patches stuck in a queue and create cybersecurity risks. In fact, there are several reasons why app packaging can create ongoing burdens and backlogs, including:
Updates restart the work: Every time a new version of an app comes out, it needs a new package, a retest, and an updated detection rule. As such, the workload grows with the number of apps, not just new requests.
Installers aren't consistent: EXE installers from different vendors can use different switches, and some even change behavior between versions. This inconsistency can create delays as investigating each one can take time.
Testing takes time and clean machines: Testing apps can be time-consuming, but it’s necessary. Skipping tests can lead to failed installs, reinstall loops, and help desk tickets, which can cost even more time and cause further delays.
Knowledge sits with a few people: Organizations often only have one or two people who manage application packaging. When one person handles all packaging steps and fixes, it can slow things down significantly when they're busy.
How AI is changing application packaging
AI is starting to change application packaging. What used to be a time-consuming manual process can now be done quickly using AI-powered agents. AI can handle many manual steps, such as reading the installer, writing install logic and detection rules, and testing the package, saving time while keeping final approval in human hands. To see how this works, read our guide to AI application packaging.
This brings us to Splashtop Agentic Packr, an AI-powered tool that helps IT teams package, validate, secure, and deploy Windows applications through Microsoft Intune, with bundles for deployment with SCCM. With it, IT teams can get apps ready for deployment quickly, while freeing up time for other pressing tasks.
Splashtop Agentic Packr runs through the entire app packaging process, including reading the installer, building a PSADT package with detection rules, testing the package on a clean VM, running a security scan, and preparing it for deployment. However, admins still make the final decisions, receiving a QA scorecard and logs to review the results before the package is published.
Package Windows apps faster with Splashtop Agentic Packr
When you deploy apps across multiple devices, you need a consistent, reliable installation process. But since every app and update requires packaging, this can be time-consuming and delay updates.
Agentic app packaging can improve the process by automating packaging, testing, and more. With Splashtop Agentic Packr, teams can automate app packaging, deployment, testing, and updates, without sacrificing visibility and control.
The result? More consistent packages, reliable testing, and less time spent researching switches and writing scripts.
Want to learn more about Splashtop Agentic Packr? See how you can make app packaging fast and efficient with AI-powered automation:
