I’ve long been a fan of having the right tools to do the job properly. Maybe you are getting your hands dirty with application packaging, or perhaps you’re managing a team of application specialists and need to commit to delivering a certain number of packages to the business on a tight schedule. Either way, you need the right software to be able to do the best job possible. Many of us here at ITNinja have had experience with a few different packaging toolsets over the years ranging from the very simple (free) offerings such as Orca, up to the fully featured, all-encompassing solutions offered by vendors such as Flexera and RayNet.

If you are managing a team of application packagers then, the “right tools for the job” translates to tools to optimise the performance of this team as a whole. For smaller organisations you can certainly use a spreadsheet to plan and execute the work; however for most medium to large organisations there are significant advantages to using Application Lifecycle Management (“ALM”) toolsets. These are designed to optimise the team’s output by providing a centralised portal where all members of the team can be assigned tasks and track their work, raise defects, manage UAT etc. Weekly reports enable management to monitor performance, and it can make proper management of SLAs possible. This results in increased customer satisfaction (that might be the business the IT team are supporting, or an actual end “customer” if you’re a service provider) which can only be a good thing for everyone.

In this post I’m going to take a look at an ALM solution called AppTracker. I first met the AppTracker team at the AppManagEvent in Utrecht in 2013 where one of their founders (Justin Pickup) spoke to me enthusiastically about their offering. I’ve since followed their progress and in their latest release (version 5) I collaborated with the AppTracker team to help implement some ITNinja community integration.

Day-to-day Usage

The tool is designed to accelerate the task of delivering software to customers from both a management and packager’s perspective. Management gets a dashboard where they can get a snapshot of the organization’s application status and quickly see historical QA and UAT results, make sure SLAs are being met and so on.

Senior management may not want to open AppTracker on a regular basis (if ever) so instead we can subscribe them to daily Dashboard emails to keep them up to date with current status. And as you’d expect, the Dashboard is fully customisable (per-user if needed) meaning only relevant Dashboard widgets get sent to each manager.


Figure 1. The Dashboard provides a snapshot of the organization’s application status

AppTracker provides an end user portal where one can search the currently supported (i.e. packaged) software titles, and can also raise new requests. Management can then review these requests and either accept them (they are then moved to the main queue) or reject them (they are marked as rejected and go no further).

Once an application has been accepted into the main queue it’s likely it will go through some form of “requirements gathering” process where the installation requirements (OS, middleware, dependencies, etc.) will be recorded, along with any installation and configuration instructions. Licencing details may also be collected here using a customisable form known as a “questionnaire”.

Once an application is ready for packaging or virtualisation the ITNinja integrations comes into play. You can quickly search for tips on each application across the ITNinja software library and then “pin” the relevant ones in AppTracker. When you revisit that application you will get the latest set of tips displayed (they are not stored offline, so any changes or updates are not missed). When it comes to streamlining application packaging, I’ve long been an advocate of checking what community tips exist as part of the process and this integration goes a long way to helping capitalize on this critical step.


Figure 2. ITNinja integration speeds up the packaging process

Once you’ve built a package, the next step for an application is typically Quality Assurance. This effort aims to ensure the application meets internal standards, and prevents those embarrassing moments where an app is presented to the business for the first time in UAT only to find that there is some issue with the way it has been packaged. AppTracker provides a “questionnaire” (custom form) for QA that allows you to setup the checks exactly as you need them. You can even add custom buttons to the form to run PowerShell scripts to make use of automation if you like.


Figure 3. Applications with their QA results

User Acceptance Testing (UAT)

AppTracker is one of the few tools which facilitates UAT. It allows you to setup a “Test” for an application which takes you through a wizard where you can specify who in the business should be doing the UAT, when they will do it, which department/office they will be approving it for, and which machine will be used for the UAT. AppTracker then sends that person an email with a calendar file to add it to their Outlook, it includes and RDP file so they can connect to the test machine, and they get a link to the sign-off page on the AppTracker portal where they can post the results (including screenshots) of the test. Once submitted the full results are viewable by AppTracker administrators.


Although I didn’t have time to play with it, the team at AppTracker assured me that the AppTracker API is quite powerful. There are PowerShell cmdlets available to handle automating most tasks in AppTracker, and other systems can be easily integrated by using AppTracker’s event and schedule driven API to call PowerShell scripts. I’m told many customers use the API to do things such as populate Active Directory groups for app deployments.


AppTracker is offered as a hosted solution in Microsoft Azure (“AppTracker Cloud”) or can be installed on-premise. Installing locally, it requires a SQL server and an IIS server, a file share (for storing attachments) and an optional SMTP relay for email notifications. If you decide to go for an on-premise installation this is typically handled by an AppTracker consultant but I’m told takes only an hour or so as it is a pretty simple process. I used AppTracker Cloud so don’t have any first-hand experience of the installation.


It is clear that AppTracker is a highly configurable product; this makes perfect sense as every organisation will have a different set of processes and controls around application management. AppTracker allows you to customise the standard processes each application will pass through (typically something along the lines of Identify, Discover, Packaging, QA, UAT, Deploy, Live) and it supports sub-processes with SLA controls so that a package can sit in “Packaging, On-hold” while we wait for the procurement team to tell us what the licence key is for a product without this impacting its SLA.


Figure 4. Default Application process and sub-processes

Each application has an “App Details” screen where various data fields can be added or removed as required. Here you can also add custom fields in the form of text fields, date fields and drop-down boxes.

Across the product you have the option to show/hide/re-label many of the tabs and fields so that you can tailor the product meet your exact requirements.


My short time with AppTracker has shown me what a huge amount of functionality is available in a very well presented solution. It’s highly customizable and easily extensible thanks to the API. While not my focus here, it is worth noting that there is a lot of migration management and optimisation capabilities here too, though I didn’t have time to investigate this. It’s well worth taking a look.

More info: