QlikSense Small Multiples: Compare 12 Branches Without the Chart Fooling You

A retail chain with twelve stores showed me its management dashboard, and that is where I finally understood the real point of QlikSense small multiples. There were twelve line charts, one per branch, sorted alphabetically on the same sheet. It looked tidy. The commercial manager pointed at the Chillán panel and said things were improving there, and the line was indeed going up. The detail is that the axis on that panel topped out at 40 million and the one for Concepción at 400. Chillán was moving inside a scale twelve times smaller, so its line rises on anything at all. Nobody lied in that meeting. The chart did it on its own.

A trellis of identical charts, with the same metric, the same color and the same scale, forces the eye to compare shapes instead of guessing magnitudes. It sounds obvious. Yet the object that does exactly that in QlikSense is called the trellis container, it lives in the Visualization bundle, and almost nobody configures it properly.

The network average hides half the story

When a company runs several comparable units (branches, plants, lines, crews, sales reps), the consolidated indicator becomes an anesthetic. That is why QlikSense small multiples turn out to be the cheapest way to take that anesthetic away. If the network sold what was budgeted, then everything is fine. But the consolidated figure is a sum, and a sum averages one unit’s disaster with another’s excellence.

The industry numbers on this are fairly brutal. A global automotive supplier with five plants producing the same assembly found a 15-point OEE gap between its best and its worst plant, building the same part to the same design. And it was not bad luck: once they identified three procedural deviations from the leading site, they cut changeover time by 11% and lifted average OEE across the whole network by 7 points in one quarter, equivalent to $2.3 million of production capacity without spending a peso on machinery.

What QlikSense small multiples show when you point them inward

Even so, the most uncomfortable piece of context is this: 62% of manufacturing companies admit they have no real-time mechanism for comparing one site’s performance against another. It is not that they lack data. They have twelve dashboards nobody can put side by side.

Twelve charts with twelve axes are not QlikSense small multiples

Here is the most common confusion. Many teams believe they are already using small multiples because they put several charts on one sheet. But repeating the object is not enough: you have to repeat it with constant visual encoding. Same color, same chart type, same category order and, crucially, same axis limits.

The automatic axis is the silent enemy. QlikSense fits each panel’s range to that panel’s data, because taken one at a time that is the correct behavior: it maximizes visible detail. Put into a grid of twelve, however, that same behavior produces twelve different scales and a false comparison. It is convenient exactly when it should not be.

The first time I built a trellis in production I left the axis on automatic and presented it that way to the committee. Someone asked about the branch that was «climbing fast». It was the worst in the network in absolute terms. The data was right and so was the expression. The problem lived in a configuration dropdown that, after two years of using the tool, I had never opened.

How to build QlikSense small multiples that do not lie

The trellis container replicates a master visualization for each value of a dimension. In other words, you design once and it multiplies. For that reason, all the serious work in QlikSense small multiples happens in three decisions taken beforehand, and none of them happens inside the object.

There can only be one measure

Before you think about the object, lock down the metric. This holds whether you build your QlikSense small multiples on bars, on lines or on a map. Because if each branch panel uses a different expression, you lost comparability before you drew anything. The measure goes in as a master measure, with the data universe closed off by Set Analysis:

// Master measure: "Net sales"
// A single criterion for the whole network. If this expression changes,
// it changes in all 12 panels at the same time.
Sum( {< TipoDoc = {'FAC','BOL'}, Anulado = {0} >} Venta )

In that expression, the TipoDoc modifier excludes credit notes and internal documents, while Anulado = {0} drops anything that was voided. Neither condition is optional. If one branch voids more than another, the comparison is contaminated without any error showing up.

Fixing the scale: the step almost everyone skips

This is the heart of the matter and what separates serious QlikSense small multiples from a decorative grid. In the master chart, the measure axis is switched from Auto a Custom, with a minimum of zero and a maximum calculated by expression. Now, that maximum cannot be the panel maximum: it has to be the maximum across the whole network. And to get it you have to escape the context the trellis itself imposes on each panel:

// Axis maximum, shared by all 12 panels.
// Sucursal=  clears the filter the trellis applies in each panel,
//            so the maximum is calculated over the whole network.
// Aggr(...)  builds the Sucursal x Mes grid so the real peak can be found.
// TOTAL      ignores the chart dimension (the month) when aggregating.
// * 1.08     leaves headroom so the tallest bar does not touch the edge.
Max( TOTAL
     Aggr(
        Sum( {< Sucursal = , TipoDoc = {'FAC','BOL'}, Anulado = {0} >} Venta )
      , Sucursal, MesNum
     )
) * 1.08

Without the Sucursal= in the Set Analysis, each panel would calculate its own maximum and we would be back to the original problem. That detail is in fact what separates a decorative trellis from one you can decide with. It is also worth testing the expression in a standalone KPI before dropping it into the axis: if it returns a different number when you look at the whole network, something in the model is reducing what it should not.

The reference line that orders the reading

With a common scale you can already compare. What is still missing, though, is the anchor point. For rate metrics (margin, compliance, OTIF, shrinkage) the most useful thing is not to show the branch value but its distance from the network. Zero becomes the network line and the eye reads gaps, not levels:

// Margin gap in percentage points: branch minus network.
// RangeMax(denom, 1) avoids division by zero in months with no sales.
  Sum( {< TipoDoc={'FAC','BOL'}, Anulado={0} >} Margen )
/ RangeMax( Sum( {< TipoDoc={'FAC','BOL'}, Anulado={0} >} Venta ), 1 )
-
  Sum( {< Sucursal=, TipoDoc={'FAC','BOL'}, Anulado={0} >} Margen )
/ RangeMax( Sum( {< Sucursal=, TipoDoc={'FAC','BOL'}, Anulado={0} >} Venta ), 1 )

One ordering problem remains. Since the trellis container sorts panels by the dimension and not by an expression, you cannot ask it for «the worst branch first». The solution goes in the script: you calculate the ranking at load time and build a label field that carries the order with it.

// ============================================================
//  Panel order in the trellis
//  The trellis sorts by dimension. So the ranking is
//  baked into the script and travels inside the label.
// ============================================================
TMP_Ranking:
LOAD
    Sucursal,
    Sum(Margen) / RangeMax(Sum(Venta), 1)   as MargenSucursal
RESIDENT Hechos
WHERE Match(TipoDoc, 'FAC', 'BOL') and Anulado = 0
GROUP BY Sucursal;
// The ORDER BY rules: 01 is the branch with the worst margin
TMP_Orden:
LOAD
    Sucursal,
    Num(RowNo(), '00') & ' · ' & Sucursal   as PanelSucursal
RESIDENT TMP_Ranking
ORDER BY MargenSucursal ASC;
MAP_Panel:
MAPPING LOAD Sucursal, PanelSucursal RESIDENT TMP_Orden;
DROP TABLES TMP_Ranking, TMP_Orden;
// The field is added to the model. The third ApplyMap argument
// is the safety net: a new branch does not break the dashboard,
// it shows up at the end flagged as '99'.
Hechos_Panel:
LOAD
    *,
    ApplyMap('MAP_Panel', Sucursal, '99 · ' & Sucursal)   as PanelSucursal
RESIDENT Hechos;
DROP TABLE Hechos;
RENAME TABLE Hechos_Panel to Hechos;

That PanelSucursal field is the one you use as the trellis dimension. The grid then reads top to bottom like a ranking, so the operations manager knows the first two panels are his agenda for the week.

What changes in the management meeting

The change is not cosmetic. It is about decision speed. Put another way, QlikSense small multiples do not buy information: they buy reaction time. A twelve-panel dashboard on a common scale puts three things in plain sight at once that previously required clicking through branch by branch: who is out of range, who has the wrong curve shape even though the level looks acceptable, and how many units share the same pattern (which is what tells a local problem apart from a network one).

In the retail case that opened this article, the trellis with a fixed scale showed something twelve separate dashboards had hidden for two quarters: four branches had the same drop in the same week. It was not local management. It was a supply break from a vendor that only served those four stores. Spotting it took twenty seconds of reading.

That is the business argument, and it is worth saying it in board language: the trellis shortens the time between the data and the right question without adding a single new figure. When the comparison is visually honest, nobody can run optimistic numbers off a favorable scale.

Four common mistakes with QlikSense small multiples

Putting too many values in the dimension. The container’s hard limit is 50 objects, but the practical limit shows up much earlier. When the field has between 10 and 15 distinct values the trellis works fine, but with many more it simply does not draw, and here is the worst part: it does not warn you. It leaves the object blank and sends you off to check the expression, which is perfectly fine.

using If() in the trellis dimension. The community consistently reports that calculated dimensions with conditionals produce odd selection and data display behavior inside the container. So if you need to group values, group them beforehand in the script with a derived field.

Mixing absolute metrics and rates in the same grid. A trellis where some panels show pesos and others percentages stops being a comparison and becomes a collage. One metric per grid, always.

Forgetting it is a Visualization bundle object. Bundle objects have limitations that native ones do not. The one that hurts most in practice: you cannot download it as data. If your finance manager lives in Excel exports, tell him beforehand, not afterward.

Best practices for QlikSense small multiples in production

• Six to twelve panels. More than that stops being a comparison and turns into wallpaper. If you have 40 branches, for example, show the trellis for the top 6 and the bottom 6 according to the script ranking.
• Strip each panel to the bone. The charts are small, so drop the gridlines and drop the legend repeated twelve times. One title per panel and nothing else.
• One color, plus one exception. Everything in the corporate color, and red only for the panel that breaks the threshold. Color only when it means something.
• A reference panel zero. Putting the whole network as the first panel, or as a background line in each one, saves you the «so what is normal?» question.
• Governance. The replicated chart must be a master visualization and the metric a master measure. That way you fix one place and all twelve panels obey.
• Document the sort criterion. If panel 01 is the worst, say so in the object title. I have seen people assume 01 was the best and take exactly the opposite decision.

One historical detail that may matter little but is worth being clear about: the trellis stopped being a third-party extension and moved into the official bundle several releases ago, around 2019 I believe, though I do not have the exact date. If you work on an old on-premise installation, check that the bundle is deployed before promising the dashboard. And if you are on Qlik Cloud, you already have it.

Twelve portraits instead of one group photo

A consolidated figure is a group photo: everyone is in it, nobody stands out. A well-built trellis is twelve portraits taken with the same camera, the same light and the same distance. The information is the same. The ability to decide with it is not. At bottom, that is all QlikSense small multiples do: they take away the chart’s ability to lie.

The question I will leave you with is not a technical one. If tomorrow you put your business units side by side, same metric and same scale, without the protection of the average, how many of them are where your monthly report says they are? You can find more practical content of this kind at hectorpincheira.com, although in this case the exercise is simpler than reading: open your app, pick a metric and fix the axis. That job takes twenty minutes.

Sources consulted: official Qlik documentation for the trellis container, Connected Manufacturing on cross-site benchmarking e Inforiver on axis scaling in small multiples.