How to Rationalise Your Application Portfolio: A Step-by-Step Method

Blank cards sorted into a few neat piles on a dark desk

Direct answer: To rationalise an application portfolio, start from a clean inventory of what is actually installed, remove the noise (drivers, runtimes, installers), and group every version and variant of a product into one application family. Then decide, family by family, whether to keep, consolidate, standardise or retire it, and name an owner for each decision. Make the changes in small, reversible steps, and keep the decisions recorded so the portfolio does not grow back.

Most organisations have tried this at least once. A spreadsheet is built, workshops are held, a list of applications to retire is agreed. A year later the estate looks much the same. The method below is designed to avoid that outcome.

What Is Application Portfolio Rationalisation?

Application portfolio rationalisation is the work of deciding which applications your organisation should keep, which should be merged or standardised, and which should go. The aim is a portfolio that is smaller, easier to patch, easier to support and easier to explain to an auditor.

The manual version usually looks like this:

  • An export and a spreadsheet. Someone pulls an inventory from the device management tool and pastes it into a workbook.
  • Scripts to tidy it. Filters and lookups try to strip out drivers and runtimes and match variant names.
  • Interviews. Business units are asked what they use and what they need.
  • A decision list. Applications are marked keep or retire, and the list is circulated.

Each step is reasonable. The trouble is that the result is a snapshot. The inventory changes the following week, the spreadsheet does not, and the decisions live in a file that nobody re-applies. A rationalisation that is not maintained is an audit, not a change.

How to Rationalise an Application Portfolio: Seven Steps

1. Set the scope

Decide what you are rationalising and why. A whole-estate exercise is different from a programme tied to a Windows 11 move, an Intune migration or a merger. Agree:

  • Which devices and business units are in scope.
  • What “done” looks like: fewer families, fewer versions, a named owner for each application, or all three.
  • Who signs off decisions, and how disputes are settled.

Scope keeps the work finite. Without it, rationalisation becomes an open-ended clean-up that loses its sponsor.

2. Build a clean inventory

You cannot rationalise what you cannot see, and you cannot rationalise noise. A raw inventory is full of rows that are not business applications at all: system components, device drivers, redistributables, help files, installation files and bundled components. Count those and every later figure is inflated.

So the first real task is to separate business applications from everything else. Do it with consistent rules, not by eye, and write the rules down so the next pass produces the same answer.

3. Group versions and variants into families

The same product turns up under many names: a renamed edition, a language pack, an installer that registers a slightly different display name. Decisions should be made once per product, not once per row.

Group every version and variant of a product under one consistent name: an application family. Be just as careful to keep look-alikes apart. Add-ins for a collaboration tool are not the tool itself, and merging them confuses versions and vulnerability ranges.

Once families exist, the portfolio usually looks very different from the raw export. It is shorter, and the real decisions become visible.

4. Decide per family: keep, consolidate, standardise or retire

For each family, make one of four decisions.

Bring whatever evidence you hold into each decision: install spread, known vulnerabilities, contract and renewal dates, business criticality and the owner’s view. Usage and contract data usually sit in other systems, so pull them in from wherever your organisation keeps them.

The figures below are illustrative, not drawn from a customer estate.

Each row gets a different response. A single “number of applications” figure would hide all of it.

5. Name an owner for every family

Every family needs someone in the business who can say yes or no. Without an owner, each decision turns into a hunt for the right person, and retirements stall because nobody feels able to approve them.

The owner is also where exceptions live. Some versions must stay: a critical system depends on them, a regulator signed them off, or a specialist team has validated a build. Record those versions against the family, with the owner’s name, so they are protected every time rather than when someone remembers.

6. Change things safely

Rationalisation decisions only matter once devices actually change. That is also where most programmes stall, because people are afraid of breaking something.

Treat every change as a small, reversible release:

  1. Package the target version properly.
  2. Send it to named testers first, and record their approval or rejection.
  3. Roll it out in phases to a growing share of devices, for example 10%, then 50%, then 100%.
  4. Keep the ability to roll back any phase.
  5. Keep devices on protected versions out of the deployment.

Retirement deserves its own step. Deploying a new version does not necessarily remove the old one, so plan the removal of retired applications and old versions explicitly, with the owner’s agreement.

7. Keep it from growing back

The final step is the one most programmes skip. Re-run discovery on a schedule. Re-apply the same rules. Make sure the decisions you made last quarter are still in force when the inventory changes. New applications should arrive into a family with an owner, not into a spreadsheet nobody opens.

For a worked example of this method applied to a large estate, see our application rationalisation case study.

How Do I Reduce Application Sprawl in an Enterprise?

Application sprawl is the version of the portfolio problem you feel every patch cycle: too many products, and too many versions of each. You reduce it with the same method. Clean the inventory, group into families, then standardise the families with the widest version spread first, starting with those that carry known vulnerabilities.

Measuring sprawl well is a topic of its own. Our guide to version debt and application sprawl covers the three measures per family and how to judge your estate against its own medians, and application sprawl is dead budget covers how to put a cost on it for the business case.

Common Pitfalls in Application Rationalisation

  • Deciding on raw rows. If drivers and runtimes are still in the list, the analysis is measuring noise.
  • Deciding per name, not per product. Variant names split one product into several, and look-alikes get merged with the wrong family.
  • Decisions that live in a file. If the next inventory refresh does not re-apply them, they are lost.
  • No owner. A retire decision with nobody to approve it never happens.
  • A big-bang cutover. One large change with no test group and no rollback is how rationalisation gets a reputation for outages.
  • Treating it as a project. The estate keeps changing. Rationalisation has to keep running.

How ALICE Rationalises an Application Portfolio

ALICE, built by Camwood, runs this method for Microsoft Intune estates, from discovery through to a controlled change. Rationalisation comes before packaging, so the decisions are made on a clean picture and then carried into deployment.

  • A clean inventory from your own tenant. ALICE reads which applications are installed on which devices, at which versions, from your own Intune through Microsoft Graph. Access is granted once by your own administrator through admin consent, and you can remove it at any time. Each sync refreshes the whole estate.
  • Eight flags, then a rationalised view. Every discovered row is checked against a centrally maintained applications database across eight flags: system component, device driver, redistributable, help files, deprecated, installation files, bundle and non-business. Flagged rows drop out of the rationalised view, which is the default view in Discover. Matching starts with exact names and moves to progressively looser rules, and a missed match never clears a decision. Web shortcuts and PWA entries are filtered out automatically.
  • Families, briefly. Variant names are consolidated into one application family, and look-alikes are kept apart. Flags apply across a whole family, and each family’s sprawl is measured alongside it.
  • Your decisions persist. Where your business view differs from the central database, your team adjusts the flags. Those manual decisions are preserved when rationalisation runs again, and rationalisation decisions, packaging status and scope settings carry over from sync to sync. The work does not reset with the next inventory.
  • Governance per family. Each family has a governance page recording its owner in the business, its excluded versions and its dependencies. Devices on excluded versions are placed in exclusion groups and kept out of deployments.
  • A controlled change. When a decision means moving devices to a standard version, ALICE packages it (from catalogue match, your own repository or an uploaded installer) and a person sends it through your own Intune: named testers in an Entra test group, with approve or reject links and an evidence form, then three production phases of 10%, 50% and 100%, each its own Entra group. Phases advance on schedule or by hand, and any phase can be rolled back. Supersedence is set at the test stage; it does not uninstall older versions, so removing a retired version stays a deliberate step.
  • Still on SCCM? ALICE can also take three exports from SCCM, so you can understand and rationalise the estate before moving to Intune. Deployment through Intune is not part of the SCCM route.

ALICE gives you the clean picture, the owners and the controlled change. The decisions to keep, consolidate or retire, and the savings that follow, are yours.

Application Rationalisation Checklist

  1. Write down the scope, the sign-off route and what “done” means.
  2. Pull an install inventory for the in-scope devices.
  3. Strip out drivers, runtimes, redistributables, installers and bundled components.
  4. Group the remaining rows into application families, keeping look-alikes apart.
  5. Mark each family keep, consolidate, standardise or retire.
  6. Name an owner for every family and record the versions that must be left alone.
  7. Move one family first: testers, then phased rollout, with rollback ready.
  8. Schedule the next discovery pass and check your decisions still hold.

Frequently Asked Questions

Build a clean inventory, remove non-business rows such as drivers and runtimes, and group versions and variants into application families. Then decide per family whether to keep, consolidate, standardise or retire, name an owner for each, change things in phased, reversible steps and keep the decisions recorded.

Rationalise From a Clean Picture

Rationalisation is not a spreadsheet you finish. It is a set of decisions you keep, and a safe way to act on them.

Start a 14-day ALICE trial, connect your Microsoft environment and see your estate as clean application families, ready for keep, consolidate, standardise and retire decisions.

Start your free trial · Or book a demo

ALICE is Camwood‘s platform for Autonomous Application Lifecycle Management: discover, rationalise, package, deploy and patch through your own Intune, with every decision kept on one record.

Latest Posts

Several near-identical glass cubes on a dark reflective surface, lit blue
Duplicate applications come in three kinds: same product under many names, many versions, and different tools doing one job. Here’s……
Rows of dark server racks in a data hall, one rack open and lit blue
An application inventory records every app, version, device, owner, dependency and vulnerability. Here’s how to build one and keep it……
A board reviewing a security shield on a large display in a dark boardroom
Six questions a risk committee should ask any platform that connects to your Microsoft tenant, what good answers look like,……