Sid Meier once described video games as “a series of interesting decisions”. If you’re pondering your next job and considering what’s important to you, or you have been offered several opportunities and are trying to decide between them, it may seem anything other than a game. Sometimes an interesting choice is very much a positive, but sometimes it can seem overwhelming; which of this set of very different options is best?

One of our colleagues introduced us to a technique which some of us find very helpful in these kinds of situations. It’s popularly known as a “decision matrix”, though the versions easily found on the web are less than ideal, since (some of us think) these have a greater chance of introducing confirmation bias.

The “trick”, we think, is to separate the qualities of the things you’re thinking about, from the things themselves. Break your decision down into a series of simple choices you can make in isolation, without second-guessing yourself.

The Decision Triangle

The ideas is to make a single list of all of the qualities, attributes, characteristics or kinds of thing that might be important to you, up to a dozen, not too many. If you’re not sure, make a list of the biggest factors you can think of, or the major properties of each option you’re presented with, whether you like those items or not.

Once you have this list, you:

  • Make a list of all unique pairs of qualities; every possible combination.
  • For each pair, chose your favourite: if you had no other option than to choose A or B, which would you choose?
  • Total up the scores.

The highest scoring qualities are the most important to you.

This sounds trivial, but can lead to surprising results.

For best results, consider randomising the order within each pair, and the order in which you’ll consider each pair.

For any list of length n there are n x (n – 1) / 2 pairs, which is why you don’t want more than a dozen or so.


Let’s imagine you’re starting a job as a zookeeper, and your boss has given you the option of looking after one particular animal: the lions, tigers, bears, monkeys, penguins or lemurs. You’re not sure which animal you’d prefer to work with.

You could list out the pairs as:

lions or tigers; lions or bears; lions or monkeys; lions or penguins; lions or lemurs; tigers or bears; tigers or monkeys; tigers or penguins; tigers or lemurs; bears or monkeys; bears or penguins; bears or lemurs; monkeys or penguins; monkeys or lemurs; penguins or lemurs.

Choose your favourite of each pair, total up the scores, and you’ve made your choice.

Or, perhaps more usefully, you could enumerate the qualities of each animal: for example, friendly, majestic, carnivorous, playful, intelligent, amusing, loveable. Then make pairs of those, choose one from each pair, total the scores, and again, you’ve made your choice, except now you understand the kinds of things that are most important to you, and this may surprise you. It may turn out you really like carnivorous animals, quite like playful animals, but aren’t too worried by whether the animal is majestic or intelligent.

Tabulating It

One way to be sure you catch all combinations is to draw things out as first a numbered list:

  1. Lions
  2. Tigers
  3. Bears
  4. Monkeys
  5. Penguins
  6. Lemurs

And then draw out the pairs, crossing out pairs you already have:

1 1 1 1 1
2 3 4 5 6

2 2 2 2 2
1 3 4 5 6

3 3 3 3 3
1 2 4 5 6

4 4 4 4 4
1 2 3 5 6

5 5 5 5 5
1 2 3 4 6

Here, we've drawn pairs vertically. You should be able to see the triangular shape of this table as it tapers towards the end, hence "decision triangle".

Then you can circle one number from each pair, and count up the results.

Coding It

If you’ve just a little bit of programming skill, it should be child’s play to code up a simple program to ask you the questions and total up the results for you.

One of our consultants demonstrates, with a little bit of “hack and slay” C#:

static void Main(string[] args)
    var random = new Random();

    var list = args.OrderBy(x => random.Next()).ToArray();

    var pairs = list.SelectMany(x => args, (x, y) => (p: x, q: y))
                    .Where(x => string.Compare(x.p, x.q) < 0)

    var scores = new Dictionary<string, int>();

    foreach (var pair in pairs)
        var options = (random.Next(0, 100) < 50) ? (p: pair.q, q: pair.p) : pair;

        Console.WriteLine($"(1) {options.p} or (2) {options.q}?");

        var choice = 0;
        while (!int.TryParse(Console.ReadLine(), out choice) ||
               choice < 1 || choice > 2) { }

        var key = choice == 1 ? options.p : options.q;

        scores.TryGetValue(key, out int score);
        score += 1;
        scores[key] = score;

    Console.WriteLine("Your priorities, highest first:");
    foreach (var item in scores.OrderByDescending(x => x.Value))