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.
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:
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.
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:
Scope keeps the work finite. Without it, rationalisation becomes an open-ended clean-up that loses its sponsor.
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.
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.
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.
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.
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:
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.
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.
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.
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.
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.
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.
Consolidating means choosing one application where several do the same job and retiring the rest. Standardising means keeping one application but moving every device to an agreed version.
Use the same method: clean the inventory, group into families, then standardise the families with the widest version spread first, starting with those carrying known vulnerabilities.
Usually because decisions live in a spreadsheet that goes stale, nobody owns the decisions, or the change is attempted as one large cutover with no test group or rollback.
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.
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.