A closer look at AppTracker

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.

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.

API

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.

Hosting

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.

Customization

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.

Summary

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.