Analysis only matters when someone understands it and acts on it. This intermediate course teaches the visual side of data work that data analysts, data scientists, statisticians and operations research analysts use every week. It builds on Intro to Data Analysis with Python and Spreadsheets for Data Work. The first module is about perception: which visual encodings people read accurately, how to match a chart type to the question being asked, and how to remove clutter so the message stands out. The second module builds charts in Python: labelled line and bar charts with matplotlib, distributions and relationships with seaborn, and small multiples that compare many groups at once. Because chart images cannot be auto-checked in the browser, the coding exercises have you compute the data behind each chart (sorted bars, monthly totals, histogram bins, shared axis limits) with pandas and NumPy, while the lessons show the plotting code to run on your own machine. The third module moves from single charts to communication: sketching a dashboard for one audience, building one in a free BI tool such as Looker Studio or Power BI Desktop, and presenting a three-slide data story with a clear recommendation.

Turn analysis into charts people read correctly: visual principles, matplotlib and seaborn, small multiples, dashboards and a short data story.

Data Visualization & Storytelling

## Why it matters

A chart is a translation. You start with numbers, encode them as visual properties (position, length, colour, size), and your reader decodes those properties back into numbers in their head. Every encoding loses some accuracy in that round trip, and some lose far more than others. If you choose well, your reader sees the right answer in a second or two. If you choose badly, they misread the data or give up.

This lesson covers the two ideas that most chart advice rests on: the ranking of visual encodings, and pre-attentive attributes.

## Not all encodings are equal

In the 1980s the statisticians William Cleveland and Robert McGill ran experiments asking people to compare values shown in different ways. Later studies (including large online replications by Jeffrey Heer and Michael Bostock) found the same order. From most to least accurate for comparing quantities:

1. **Position on a common scale**: dots or bar ends lined up against the same axis.
2. **Position on non-aligned scales**: the same, but in separate panels.
3. **Length**: bars that start from the same baseline.
4. **Angle and slope**: pie slices, line steepness.
5. **Area**: bubbles, treemap rectangles.
6. **Colour intensity (saturation, lightness)**: heatmap cells, shaded maps.

That ranking explains a lot of everyday advice:

- A bar chart beats a pie chart for comparing categories, because length on a shared baseline is easier to judge than angle. In a pie with slices of 23% and 26%, most people cannot tell which is bigger. In a bar chart they can.
- Bubble charts exaggerate or hide differences, because people underestimate area. A circle with twice the area does not look twice as big.
- Heatmaps are good for spotting patterns (where is it hot?) but poor for reading exact values. Add the numbers as labels if precision matters.

**Rule of thumb:** put the comparison that matters most on position or length. Use colour, size and shape for secondary information.

## Pre-attentive attributes

Some visual differences are noticed before conscious attention, in roughly a quarter of a second. These are called **pre-attentive attributes**. Common ones:

- **Colour hue** (one orange bar among grey ones)
- **Intensity** (one dark item among light ones)
- **Size** (one large dot)
- **Orientation** (one tilted line)
- **Enclosure** (a box around one region)
- **Added marks** (an annotation or a bold label)

Try it mentally. Picture a page of 200 grey digits with every 7 printed in orange. You find the 7s instantly. Print them in the same grey and you have to read every digit.

This is a powerful tool and an easy one to misuse. Pre-attentive attributes work only when **one or two things** stand out. If every bar is a different bright colour, nothing stands out and the reader has to consult a legend for each bar.

## Worked example

You need to show that the North region missed its sales target while four other regions hit theirs.

**Weak version:** a pie chart of sales by region in five bright colours, with a legend on the right. The reader must match colours to the legend, compare angles, and still has no idea what the target was.

**Better version:**

- A horizontal bar chart sorted from highest to lowest (position and length on a shared baseline).
- All bars grey except North, which is orange (one pre-attentive highlight).
- A thin vertical line at the target value, labelled "Target".
- A title that states the finding: "North was the only region below target in Q3."

The data is identical. The second version answers the question before the reader even reads the axis labels.

## Colour with care

- **Categorical data** (regions, products): distinct hues, ideally no more than about six. Beyond that, group or highlight.
- **Ordered data** (low to high): one hue that runs from light to dark, called a sequential palette.
- **Data with a meaningful midpoint** (profit vs loss, above vs below average): two hues diverging from a neutral middle.
- **Accessibility:** about 1 in 12 men and 1 in 200 women have some colour vision deficiency, most often red-green. Avoid relying on red vs green alone; add labels, different lightness, or position. Tools such as ColorBrewer and the matplotlib "viridis" palette are designed to stay readable.

## Common mistakes

- **Truncated bar axes.** Bars encode value by length, so a bar axis must start at zero. Starting at 90 makes 92 look twice as big as 91. (Line charts and dot plots may zoom in, because they encode position, not length.)
- **3D effects.** Perspective distorts length and angle and hides values behind other bars.
- **Rainbow colour scales** for ordered data. The hue changes create false boundaries.
- **Too many highlights.** If three things are bold, none of them are.

## Quick recap

- Readers decode position and length most accurately; angle, area and colour intensity less so.
- Put your key comparison on a shared axis.
- Use one pre-attentive attribute, sparingly, to point at what matters.
- Choose a colour scheme that matches the data type, and never rely on colour alone.


Pick visual encodings that people decode quickly and accurately, and use pre-attentive attributes to direct attention.

How people read charts

Data Visualization: Preattentive Attributes

## Why it matters

"What chart should I use?" is the wrong first question. The right first question is "what does my reader need to find out?" Once you can name the question, the chart type nearly chooses itself. Most business and research questions fall into five families, and each family has one or two charts that answer it well.

## The five question families

| Question | Example | Good first choice | Also consider |
|---|---|---|---|
| **Comparison** across categories | Which product sold most? | Bar chart (horizontal if labels are long) | Dot plot, lollipop chart |
| **Change over time** | How did monthly sign-ups change? | Line chart | Column chart for few periods, area chart for totals |
| **Distribution** | How long do deliveries usually take? | Histogram | Box plot, density plot, strip plot |
| **Relationship** between two measures | Do longer sessions mean more purchases? | Scatter plot | Scatter with trend line, bubble chart, heatmap for many points |
| **Part-to-whole** | What share of revenue comes from each channel? | Stacked bar (100%) or simple bar of shares | Pie only for 2 to 3 slices; treemap for hierarchies |

A sixth family, **geography** ("where?"), uses maps, but only when location itself matters. A map of sales by state is often better as a sorted bar chart, because large, empty states dominate a map visually.

## Worked examples

**1. "Which of our 12 support teams resolves tickets fastest?"**
This is a comparison across categories. Use a horizontal bar chart of median resolution time, sorted from fastest to slowest. Sorting matters: an alphabetical order forces the reader to hunt for the ranking.

**2. "Is our weekly active user count growing?"**
Change over time, so use a line chart with weeks on the x-axis. Time almost always goes left to right. If you have many series (say one per country), do not draw 30 tangled lines; highlight one or two and grey the rest, or use small multiples (Module 2).

**3. "Are most orders small, or do a few large orders dominate?"**
A question about distribution, so use a histogram of order value. An average alone would hide the shape: a mean of 50 could come from many orders near 50, or from many orders near 10 plus a few at 500. If you need to compare distributions across several groups, side-by-side box plots save space.

**4. "Do customers who use the app more spend more?"**
Relationship, so use a scatter plot with usage on x and spend on y. Each dot is one customer. With thousands of points, reduce dot opacity or use a 2D histogram so overlapping points remain visible. Remember that a pattern shows association, not cause.

**5. "What share of support tickets come from each channel?"**
Part-to-whole. With three channels a pie can work, but a bar chart of percentages sorted descending is easier to read, and it still works with eight channels. To show how the mix changes over time, use a 100% stacked bar per month, and put the most important category on the baseline so its changes are easiest to read.

## Tables are allowed

When readers need to look up exact values ("what was March revenue in Spain?"), a well-formatted table beats any chart. Charts show shape and pattern; tables show precise values. A dashboard often needs both.

## Questions to ask before you pick

1. **What is the one question?** Write it as a sentence. If you have three questions, you may need three charts.
2. **What type is each variable?** Categorical (region), ordinal (small, medium, large), continuous (revenue), or time.
3. **How many categories or points?** Five bars are easy; 50 bars need sorting, grouping or filtering.
4. **Who is reading, and where?** An executive skimming a slide needs one obvious message. An analyst exploring in a notebook can handle a dense scatter matrix.

## Common mistakes

- **Line charts for categories.** A line implies continuity, so connecting "Sales, Marketing, Support" with a line suggests a trend that does not exist.
- **Pie charts with many slices.** Beyond three or four slices, angles become impossible to compare.
- **Dual y-axes.** Two scales on one chart let you make any two series look correlated by stretching one axis. Use two aligned charts instead.
- **Unsorted bars.** Sort by value unless the categories have a natural order (months, age bands, survey scales).
- **Choosing for novelty.** Radial charts, word clouds and Sankey diagrams look impressive but are hard to read accurately. Use them only when their special strength (flows for Sankey, for example) is the point.

## Quick recap

- Start from the reader's question, not the chart gallery.
- Comparison: bars. Time: lines. Distribution: histograms or box plots. Relationship: scatter. Part-to-whole: sorted bars or 100% stacked bars.
- Sort categories, keep time left to right, and use a table when exact values matter.


Match the chart type to the question: comparison, change over time, distribution, relationship or part-to-whole.

Choosing the chart

How to Choose the Best Chart for Your Data Visualization: Ask Yourself These 3 Key Questions

How To Choose The Right Graph (Types of Graphs and When To Use Them)

## Why it matters

Every mark on a chart costs the reader a little attention: gridlines, borders, tick marks, legends, background shading, decimal places. Some of those marks help. Many do not. Edward Tufte called the useless ones **chart junk** and argued for a high **data-ink ratio**: most of the ink should show data. Cole Nussbaumer Knaflic's *Storytelling with Data* turns this into a practical habit: remove everything that does not help the message, then add back emphasis where it does.

Decluttering is not about minimalism for its own sake. It is about lowering the effort it takes to see the point.

## A decluttering checklist

Work through these in order on any default chart from Excel, Google Sheets or matplotlib:

1. **Remove the chart border and background colour.** White space separates the chart well enough.
2. **Remove or lighten gridlines.** If you need them for reading values, make them thin and light grey.
3. **Remove the legend when you can label directly.** Put the series name at the end of each line, or label bars on the axis. A legend forces eye travel back and forth.
4. **Drop redundant axis labels.** If the title says "Monthly revenue ($k)", the y-axis does not need "Revenue in thousands of dollars" as well.
5. **Simplify numbers.** Use 1.2M instead of 1,200,000.00, and round labels to the precision that matters.
6. **Sort and group.** Sort bars by value. Fold a long tail of tiny categories into "Other".
7. **Use colour on purpose.** Make everything grey, then colour only the one series or bar you want people to look at.
8. **Write a takeaway title.** Replace "Tickets by category" with "Shipping problems drive the most support tickets".

## Worked example

A default chart of support tickets by category has: a grey background, a box border, eight bars in eight different colours, a legend repeating the category names, gridlines every 50 tickets, and values labelled with two decimals.

After decluttering:

- Bars sorted from most to fewest tickets, with the four smallest categories folded into "Other" (because nobody will act on a bar for 22 tickets).
- All bars grey except "Shipping", in orange, because that is the category the team will fix next quarter.
- No legend (the category names are on the axis), no border, no background, no gridlines; each bar has a whole-number label at its end.
- Title: "Shipping issues are our largest ticket category".

Here is how that chart looks in matplotlib. The data preparation, which you will write in the activity, happens first:

```python
import matplotlib.pyplot as plt

spec = [("Shipping", 530), ("Login", 412), ("Billing", 287), ("Returns", 198), ("Other", 218)]
labels = [label for label, _ in spec]
values = [value for _, value in spec]
colors = ["#d95f02" if label == "Shipping" else "#bbbbbb" for label in labels]

fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.barh(labels, values, color=colors)
ax.invert_yaxis()                      # largest bar at the top
ax.bar_label(bars, padding=3)          # direct labels instead of gridlines
for side in ["top", "right", "bottom"]:
    ax.spines[side].set_visible(False) # remove the box
ax.xaxis.set_visible(False)            # the labels carry the values
ax.set_title("Shipping issues are our largest ticket category", loc="left")
plt.tight_layout()
plt.show()
```

Notice what each line does: `invert_yaxis` keeps the sort order reading top to bottom, `bar_label` puts values where the eye already is, and removing spines strips the frame.

## When not to remove things

- **Keep the zero baseline** on bar charts.
- **Keep units and sources.** A chart without units or a data source is not trustworthy. A small grey footnote ("Source: Zendesk export, Q3 2026") costs almost nothing.
- **Keep context the reader needs**, such as a target line or the previous year for comparison. Context is not clutter if it changes the interpretation.
- **Exploratory charts** for yourself can stay rough. Declutter the charts other people will see.

## Common mistakes

- Removing axis labels without labelling the data directly, so no values can be read at all.
- Folding important categories into "Other" just to tidy up. Decide the cut-off from what the audience needs, not from aesthetics.
- Highlighting with red and green only, which many readers cannot distinguish.
- Keeping the default title, which describes the chart instead of stating the insight.

## Quick recap

- Default charts carry clutter: borders, heavy gridlines, legends, extra decimals, rainbow colours.
- Declutter in order: frame, gridlines, legend, labels, numbers, sorting, colour, title.
- Grey everything, then highlight one thing.
- Keep baselines, units, sources and context.

## Try it

Open the **Do** tab to write the data preparation behind a decluttered bar chart: sort, fold the tail into "Other", and pick highlight colours.


Remove chart junk step by step so the data and the message are the first things a reader sees.

Decluttering

How to declutter data visualizations (5 steps)

How to eliminate clutter from Excel graphs

Learn how people decode charts, pick the chart that answers the question, and strip away clutter so the message is obvious.

Visual Principles

## Why it matters

Matplotlib is the foundation of plotting in Python. pandas' `.plot()`, seaborn and many other libraries draw with it underneath, so knowing its core model lets you fix any chart, whatever library made it. You will run the plotting code on your own machine (Jupyter, VS Code or Google Colab); the in-browser activity focuses on the data preparation that every chart needs.

## The core model: figure and axes

Matplotlib has two layers you will use constantly:

- **Figure**: the whole canvas (the image file or window).
- **Axes**: one plotting area inside the figure, with its own x-axis, y-axis, title and data. A figure can hold several axes.

Always start with `plt.subplots()`, which returns both:

```python
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 4))   # width, height in inches
```

Then call methods on `ax`: `ax.plot`, `ax.bar`, `ax.set_title`, `ax.set_xlabel`. This "object-oriented" style is clearer than calling `plt.plot` repeatedly, especially once you have more than one chart in a figure.

## A labelled line chart

```python
import pandas as pd
import matplotlib.pyplot as plt

orders = pd.read_csv("orders.csv", parse_dates=["date"])
monthly = orders.groupby(orders["date"].dt.strftime("%Y-%m"))["revenue"].sum()

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(monthly.index, monthly.values, marker="o", color="#1b9e77", linewidth=2)
ax.set_title("Monthly revenue, Jan to May 2026", loc="left")
ax.set_xlabel("Month")
ax.set_ylabel("Revenue ($)")
ax.set_ylim(bottom=0)                     # honest baseline
ax.spines[["top", "right"]].set_visible(False)
ax.grid(axis="y", color="#dddddd", linewidth=0.8)
fig.tight_layout()
fig.savefig("monthly_revenue.png", dpi=150)
```

What each part does:

- `groupby(...).sum()` turns many orders into one value per month. Getting this step right is most of the work, which is why the activity practises it.
- `marker="o"` shows where the actual data points are, useful with few periods.
- `set_ylim(bottom=0)` is optional for line charts, but it avoids exaggerating small changes when your audience might over-read the slope.
- `tight_layout()` stops labels being cut off; `savefig` writes a file at a sensible resolution.

## A sorted bar chart

```python
by_region = orders.groupby("region")["revenue"].sum().sort_values()

fig, ax = plt.subplots(figsize=(6, 3))
bars = ax.barh(by_region.index, by_region.values, color="#7570b3")
ax.bar_label(bars, fmt="{:,.0f}", padding=3)
ax.set_title("Revenue by region", loc="left")
ax.set_xlabel("Revenue ($)")
ax.spines[["top", "right"]].set_visible(False)
fig.tight_layout()
```

`barh` draws horizontal bars, which suit text labels. Matplotlib draws the first bar at the bottom, so sorting ascending puts the largest at the top. `bar_label` (matplotlib 3.4+) adds value labels, and `fmt="{:,.0f}"` adds thousands separators.

## Several charts in one figure

```python
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(11, 4))
ax1.plot(monthly.index, monthly.values)
ax2.barh(by_region.index, by_region.values)
fig.suptitle("Q1 to Q2 sales overview")
```

`plt.subplots(rows, cols)` returns an array of axes. You will use this for small multiples later in the module.

## Saving and sharing

- Use `savefig("name.png", dpi=150)` for slides and documents, or `.svg` for crisp scaling on the web.
- Set `figsize` before plotting; resizing an image afterwards blurs text.
- In Jupyter, a chart shows automatically at the end of a cell; in scripts, call `plt.show()`.

## Common mistakes

- **Mixing the `plt.` and `ax.` styles** in the same figure. Titles end up on the wrong chart. Pick `ax.` methods.
- **Plotting unaggregated data.** Plotting 10,000 raw orders as a line gives a scribble. Aggregate first.
- **Unsorted time.** If months are strings, make sure they are sorted ("2026-10" sorts correctly; "Oct 2026" does not). Using ISO "YYYY-MM" strings or real dates avoids this.
- **Missing units.** "Revenue" alone does not say dollars or thousands of dollars.
- **Default titles.** Matplotlib adds none by default; always add one, ideally stating the takeaway.

## Quick recap

- `fig, ax = plt.subplots()` then call methods on `ax`.
- Aggregate with pandas, then plot: `ax.plot` for time, `ax.barh` for sorted categories.
- Label axes with units, set honest baselines, remove extra spines, `tight_layout()`, `savefig`.

## Try it

In the **Do** tab, use pandas to compute the monthly series and the sorted region totals that feed these two charts, plus a takeaway title.


Build a clearly labelled line chart and bar chart with matplotlib's figure and axes interface.

Matplotlib essentials

Matplotlib Tutorial (Part 1): Creating and Customizing Our First Plots

Matplotlib Tutorial (Part 2): Bar Charts and Analyzing Data from CSVs

## Why it matters

Many questions analysts get are about **spread** and **association**: how variable are delivery times, do longer distances mean longer deliveries, is one group different from another? seaborn is a Python library built on matplotlib that draws these statistical charts in one line, straight from a pandas DataFrame. It is fast for exploration and produces clean defaults. The catch is that it makes decisions for you (bin widths, smoothing, confidence bands) that you need to understand before you show the chart to anyone.

## Setup

```python
import seaborn as sns
import matplotlib.pyplot as plt

df = sns.load_dataset("tips")   # restaurant bills, tips, day, time, party size
sns.set_theme(style="whitegrid")
```

seaborn functions take `data=` (a DataFrame) and column names as strings for `x`, `y` and `hue`. Each returns a matplotlib Axes, so you can still use `ax.set_title` and everything from the previous lesson.

## Distributions

**Histogram:**

```python
ax = sns.histplot(data=df, x="total_bill", binwidth=5)
ax.set(title="Most bills are between $10 and $25", xlabel="Total bill ($)", ylabel="Number of bills")
```

A histogram splits the range into **bins** and counts how many values fall in each. The bin width changes the story: very wide bins hide detail, very narrow bins show noise. seaborn picks a width automatically; set `binwidth` (or `bins`) yourself and try two or three values before choosing. Starting bins on round numbers (0, 5, 10) makes the chart easier to read, which is what you will compute in the activity.

**Density (KDE) curve:** `sns.kdeplot(data=df, x="total_bill")` draws a smoothed version. It is good for comparing shapes, but it can suggest values that do not exist (for example, negative bills near zero). Use histograms when your audience is not used to density plots.

**Comparing groups:** box plots and violin plots compare a distribution across categories.

```python
ax = sns.boxplot(data=df, x="day", y="total_bill", order=["Thur", "Fri", "Sat", "Sun"])
```

A box plot shows the median (middle line), the interquartile range (the box, the middle 50% of values) and outliers (dots beyond 1.5 times the IQR). It is compact, but it hides the number of observations and multi-peaked shapes; adding `sns.stripplot(..., color="0.3", size=3)` on top shows the raw points.

## Relationships

**Scatter plot:**

```python
ax = sns.scatterplot(data=df, x="total_bill", y="tip", hue="time", alpha=0.7)
```

Each dot is one row. `hue` colours dots by a category; `alpha` makes overlaps visible.

**Scatter with a fitted line:**

```python
ax = sns.regplot(data=df, x="total_bill", y="tip", scatter_kws={"alpha": 0.5})
```

`regplot` adds a least-squares line and a shaded 95% confidence band for the line. Say what that band is if you present it; it is not a range for individual points.

**Putting a number on it.** The Pearson correlation coefficient *r* runs from -1 to 1 and measures how close the points are to a straight line:

```python
r = df["total_bill"].corr(df["tip"])   # about 0.68
```

Values near 0 mean no linear relationship (there could still be a curved one, which is why you always look at the scatter plot). Correlation does not show cause: bigger bills and bigger tips both come from bigger parties.

## Figure-level functions

`sns.displot`, `sns.relplot` and `sns.catplot` are "figure-level" versions that can split into panels with `col=` and `row=`. You will use them for small multiples in the next lesson.

## Common mistakes

- **Accepting default bins.** Always try a few bin widths, and say what width you used.
- **Overplotting.** Thousands of opaque dots form a blob. Use `alpha`, smaller markers, or `sns.histplot(x=..., y=...)` for a 2D histogram.
- **Reading the regression band as a prediction range.** It shows uncertainty in the line, not where individual points will fall.
- **Using r alone.** Very different datasets can share the same r (Anscombe's quartet is the classic demonstration). Plot first.
- **Box plots for tiny groups.** With five observations, show the points instead.

## Quick recap

- seaborn draws statistical charts from DataFrame columns and returns matplotlib Axes.
- Distributions: `histplot` (choose the bin width), `kdeplot`, `boxplot`, `violinplot`.
- Relationships: `scatterplot`, `regplot`; summarise with Pearson's r, but always look at the plot.

## Try it

In the **Do** tab, compute histogram bin edges, bin counts and a correlation coefficient with NumPy: the numbers behind a seaborn histogram and scatter plot.


Use seaborn to plot distributions and relationships, and understand the bins and statistics behind each plot.

Statistical charts

Seaborn histplot | How to make a Seaborn histogram plot with Python code

Seaborn scatter plot | How to make and style a scatterplot in Python seaborn

## Why it matters

Plot monthly sales for five regions on one line chart and you get five crossing lines in five colours, a legend, and a reader squinting to work out which line is South. Plot 20 regions and the chart is unreadable. **Small multiples**, a term popularised by Edward Tufte, solve this: draw one small chart per group, with identical axes and scales, arranged in a grid. The reader learns how to read one panel, then compares all of them at a glance. Analysts also call these facet plots, trellis charts or panel charts.

## What makes small multiples work

1. **Same chart type in every panel.** Every panel is a line chart, or every panel is a histogram.
2. **Shared scales.** The y-axis must run from the same minimum to the same maximum in every panel. Otherwise a flat line in one panel can look as steep as a big rise in another. This is the most important rule.
3. **Meaningful order.** Order panels by something useful (largest total first, or geography), not alphabetically by default.
4. **Minimal labels.** Put axis labels only on the outer edge of the grid and a short title on each panel.
5. **A shared highlight or reference** when useful, such as the company average drawn in grey in every panel.

## Small multiples in matplotlib

```python
import math
import matplotlib.pyplot as plt

regions = ["North", "West", "South", "East", "Central"]   # ordered by total
ncols = 3
nrows = math.ceil(len(regions) / ncols)
fig, axes = plt.subplots(nrows, ncols, figsize=(10, 5), sharex=True, sharey=True)

for ax, region in zip(axes.flat, regions):
    data = sales[sales["region"] == region].sort_values("month")
    ax.plot(data["month"], data["units"], color="#1b9e77")
    ax.set_title(region, loc="left", fontsize=10)
    ax.set_ylim(0, 200)
    ax.tick_params(axis="x", labelrotation=45)

for ax in axes.flat[len(regions):]:
    ax.set_visible(False)          # hide the unused sixth panel

fig.suptitle("North is growing fastest; West is declining", x=0.01, ha="left")
fig.tight_layout()
```

`sharex=True, sharey=True` keeps scales identical and removes repeated tick labels. The loop over `axes.flat` fills the grid row by row. Five panels in a 3-column grid need 2 rows, leaving one empty panel to hide.

## Small multiples in seaborn

seaborn's figure-level functions do the grid for you with `col=` (and `row=`):

```python
import seaborn as sns

g = sns.relplot(
    data=sales, x="month", y="units", col="region",
    col_wrap=3, kind="line", height=2.5,
    col_order=["North", "West", "South", "East", "Central"],
)
g.set_titles("{col_name}")
g.set_axis_labels("", "Units sold")
```

`col_wrap=3` wraps panels into rows of three. `displot(..., col="region")` does the same for histograms, and `catplot` for bar and box plots. These functions share axes by default; pass `facet_kws={"sharey": False}` only if you have a strong reason, and say so on the chart.

## Worked example: when to share and when not

Five regions sell between 45 and 171 units a month. With a shared y-axis from 0 to 200, the reader immediately sees North growing, West shrinking and Central small but steady.

Now imagine one region sells 10,000 units and the others about 100. A shared axis squashes the small regions into flat lines at the bottom. Options:

- Show the big region separately and share the axis across the rest.
- Plot **percentage change from the first month** instead of raw units, so every region is on a comparable scale.
- Use independent axes, but label clearly ("each panel has its own scale").

## Common mistakes

- **Independent y-axes by accident.** Many tools default to auto-scaling each panel. Check.
- **Too many panels.** Beyond about 20 to 30, consider grouping or showing the top ones plus "all others".
- **Panels that are too small to read.** Each one should still show its pattern; drop tick labels before shrinking further.
- **Alphabetical ordering** when a value-based order would make the pattern obvious.
- **Colour that means different things in different panels.** Keep encodings identical.

## Quick recap

- Small multiples are a grid of identical small charts, one per group.
- Share scales, order panels meaningfully, and keep labels on the outer edge.
- matplotlib: `plt.subplots(rows, cols, sharex=True, sharey=True)`; seaborn: `relplot`/`displot`/`catplot` with `col=` and `col_wrap=`.

## Try it

In the **Do** tab, prepare the data for a small-multiples chart: per-panel series, a shared y-limit, the grid shape and the panel order.


Compare many groups with a grid of small, consistent charts instead of one tangled chart.

Small multiples

Seaborn FacetGrid | How to make Small Multiples with Python Seaborn | Titles, Hue, Legend

Matplotlib Tutorial (Part 10): Subplots

Build labelled line and bar charts with matplotlib, distribution and relationship plots with seaborn, and small multiples for comparing groups.

Charts in Python

Pick one audience and write one sentence: who checks this dashboard, how often, and which decision it helps them make (for example, a café owner each Monday deciding how much stock to order).

List three to five questions that person needs answered to make that decision.

For each question, choose one tile: a headline number, a trend line, a sorted bar chart or a short table. Write which chart type and why.

Add a comparison to every headline number (vs target, vs last period or vs last year) and write how it would be shown.

Draw the layout as boxes on one page: the most important KPI top-left, headline numbers across the top, trends in the middle, detail at the bottom.

Write a short definition for each metric (what is included and excluded) and note where the data would come from and how often it refreshes.

Show the sketch to someone else for two minutes, then ask what they think the dashboard is telling them. Note anything they misread.

## Why it matters

A dashboard is a set of charts and numbers, usually on one screen, that someone checks regularly to monitor something and decide what to do. Most dashboards fail not because of bad charts but because nobody decided **who** it was for and **what decision** it supports. The result is 25 tiles, five filters and no clear message, and people go back to asking the analyst for a spreadsheet.

Good dashboard design starts on paper, long before any BI tool.

## Three kinds of dashboard

- **Strategic** (executives, checked weekly or monthly): a handful of top-level KPIs against targets, with trends. "Are we on track?"
- **Operational** (team leads, checked daily or live): current status and exceptions. "What needs attention right now?" Think support queue size, orders stuck in shipping.
- **Analytical** (analysts, explored as needed): filters and breakdowns for investigating why something changed.

Trying to make one dashboard serve all three usually serves none. Pick one.

## The design process

**1. Name the audience and their decisions.** Write one sentence: "The support team lead checks this every morning to decide where to assign agents." If you cannot write this sentence, you are not ready to build.

**2. List the questions.** From the decision, list three to five questions. "How many tickets are open? Is the queue growing? Which category is backed up? Are we meeting the 24-hour response target?"

**3. Choose KPIs and charts for each question.** Each question gets one tile: a big number (with comparison), a trend line, a sorted bar chart, or a short table. Use the chart-choice rules from Module 1.

**4. Add comparison to every number.** "1,240 open tickets" means nothing alone. "1,240 open tickets, up 18% vs last Monday, target under 1,000" tells the reader whether to worry. Comparisons can be: vs target, vs previous period, vs same period last year, or vs average.

**5. Lay out by priority.** People read screens in an F or Z pattern: top-left first. Put the most important KPI there, a row of headline numbers across the top, trends in the middle, and detail (breakdowns, tables) at the bottom.

**6. Keep it to one screen.** If it scrolls, the bottom is rarely seen. Five to nine tiles is a sensible range.

**7. Decide filters sparingly.** A date range and one key dimension (region, team) are often enough. Every filter is something the reader has to set correctly.

## Worked example: support team lead

Audience: support team lead, every morning. Decision: where to assign agents today.

Wireframe (sketched as boxes on paper):

```text
+----------------+----------------+----------------+----------------+
| Open tickets   | New yesterday  | Median first   | % within 24h   |
| 1,240 (+18%)   | 410 (-3%)      | response 6.2h  | 91% (target 95)|
+----------------+----------------+----------------+----------------+
| Open tickets per day, last 30 days (line, target line at 1,000)   |
+-----------------------------------+-------------------------------+
| Open tickets by category (sorted  | Oldest 10 open tickets        |
| bars, Shipping highlighted)       | (table: id, age, category)    |
+-----------------------------------+-------------------------------+
Filters: date range, team.  Data refreshed hourly from the help desk.
```

Each tile answers one question from step 2. The headline row uses colour only for the KPI that misses its target. The table at the bottom is actionable: the lead can assign those exact tickets.

## Practical details that build trust

- **Show when the data was refreshed** and where it comes from.
- **Define every metric**, in a tooltip or an "About" panel: what counts as "open"? Are spam tickets excluded?
- **Use consistent colours**: if Shipping is orange in one tile, it is orange everywhere.
- **Round sensibly**: 6.2h, not 6.18734h.

## Common mistakes

- Building first and asking questions later.
- Vanity metrics (total sign-ups ever) that only go up and never change a decision.
- Gauges and speedometers that use a lot of space for one number.
- Every tile a different colour scheme.
- No comparisons, so nobody can tell good from bad.

## Quick recap

- One audience, one set of decisions, three to five questions.
- One tile per question, each number with a comparison.
- Most important at top-left; detail at the bottom; one screen; few filters.
- Show definitions and refresh times.

## Try it

The **Do** tab walks you through sketching a dashboard on paper for one audience of your choice.


Sketch a dashboard for one audience by starting from their decisions, choosing a few KPIs, and laying them out by priority.

Dashboard design

12 Dashboard design tips for better data visualization

Data Dashboard Design Best Practices

Create a small sample dataset with columns date, region, category, units and revenue (at least 100 rows over several months). You can generate it in Python or type a short version into a spreadsheet.

Connect the dataset in your chosen tool (Google Sheets or CSV upload in Looker Studio; Get data > Excel/CSV in Power BI Desktop).

Check the field types: date is a date, units and revenue are numbers. Fix any that are text.

Create one central measure for total revenue (a calculated field in Looker Studio or a DAX measure in Power BI).

Add a headline number for total revenue with a comparison to the previous period.

Add a monthly revenue trend chart and a bar chart of revenue by category sorted descending.

Add a date range filter and one region filter, and confirm every chart responds to them.

Add a text box with the data source, a definition of revenue and the date you built it.

Take a screenshot for your portfolio. If you shared the report, set sharing to view-only, or remove sharing when you are done.

## Why it matters

Python is ideal for analysis and one-off charts, but most organisations share regular reporting through **business intelligence (BI) tools**: Power BI, Tableau, Looker Studio, Looker, Qlik, Metabase, Apache Superset and others. Job postings for data analysts mention at least one of these more often than not. The good news is that they share the same core ideas, so learning one makes the next much easier.

## What a BI tool does

Almost every BI tool has the same five parts:

1. **Data connection.** Connect to a spreadsheet, CSV, database or warehouse (Google Sheets, Excel, PostgreSQL, BigQuery, Snowflake...). Some tools import a copy; others query the source live.
2. **Data model.** Define tables and how they relate (for example, `orders` joined to `customers` on `customer_id`), set data types, and mark which fields are dimensions and which are measures.
3. **Calculated fields and measures.** Formulas such as `Revenue = SUM(quantity * unit_price)` or `Conversion rate = buyers / visitors`. Defining a metric once, centrally, is what keeps every chart consistent.
4. **Visuals.** Drag fields onto a chart: a dimension (region, month) on an axis, a measure (revenue) as the value.
5. **Interactivity and sharing.** Filters, date pickers, drill-down, scheduled refresh, and sharing with permissions.

**Dimensions vs measures** is the key vocabulary. A dimension is something you group or filter by (category, date, region). A measure is a number you aggregate (sum of revenue, count of orders, average delivery time). Most confusing BI results come from aggregating the wrong way, such as averaging an average.

## A quick tour of free options

| Tool | Cost to learn | Runs on | Notes |
|---|---|---|---|
| **Looker Studio** (Google) | Free with a Google account | Web browser | Easy sharing; great with Google Sheets and BigQuery. |
| **Power BI Desktop** (Microsoft) | Free download | Windows only | Very common in job postings; publishing to the online service needs a work account and often a licence. |
| **Tableau Public** | Free | Windows, macOS | Everything you publish is **public**; never upload private data. |
| **Metabase / Superset** | Free, open source | Self-hosted (Docker) | Popular in startups; needs a little setup. |

Pricing and features change, so check each vendor's site before relying on a feature. Free tiers are enough to learn and to build portfolio pieces. Never upload confidential or personal data from work or school to a public or personal account.

## Worked example: a sales dashboard in Looker Studio

1. Put a small dataset in Google Sheets: columns `date`, `region`, `category`, `units`, `revenue` (a few hundred rows is plenty; you can generate them with pandas or use a public sample dataset).
2. In Looker Studio, create a blank report and add the sheet as a data source. Check each field's type: `date` should be a Date, `revenue` a Number (currency).
3. Add a **scorecard** for total revenue and set "comparison date range" to the previous period. This gives you the number plus a percentage change.
4. Add a **time series chart** with `date` (granularity: month) and `revenue`.
5. Add a **bar chart** with `category` as the dimension, `revenue` as the metric, sorted descending.
6. Add a **date range control** and a **drop-down control** for `region`. Every chart on the page now responds to them.
7. Add a text box with the data source and a one-line definition of revenue.
8. Use **Share** (view-only) to send it to a friend for feedback, or keep it private.

Power BI Desktop follows the same path: Get data, check types in Power Query, build visuals on the report canvas, add slicers (filters), and write measures in DAX, such as `Total Revenue = SUM(Sales[revenue])`.

## Common mistakes

- **Aggregating twice.** Averaging a column that already contains averages gives a wrong overall average. Compute ratios from sums: `SUM(buyers) / SUM(visitors)`.
- **Wrong field types.** A date stored as text sorts alphabetically and cannot be grouped by month.
- **Metrics defined in each chart.** Define them once as a calculated field or measure.
- **Publishing private data publicly**, especially on Tableau Public.
- **Over-filtering.** Ten filters make a dashboard hard to use and easy to misread.

## Quick recap

- BI tools connect data, model it, define measures, draw visuals and share them with filters.
- Dimensions are grouped by; measures are aggregated.
- Learn one free tool well; the concepts transfer.
- Define metrics once, check field types, and keep private data private.

## Try it

The **Do** tab walks you through building a small dashboard in Looker Studio or Power BI Desktop, using only free tools and sample data.


Understand what BI tools do and build a small interactive dashboard in a free tool such as Looker Studio or Power BI Desktop.

BI tools tour

Looker Studio Tutorial For Beginners

Power BI from ZERO to Your First Dashboard (in 20 Minutes)

Write your big idea in one or two sentences: we should [action] because [evidence], which will [benefit].

Write the three slide titles as full-sentence takeaways (context and question, key evidence, recommendation and ask). Check that the titles alone tell the story.

Build slide 2's chart: decluttered, one highlight colour, a direct annotation at the key point, rounded numbers.

On slide 3, write the recommendation, the expected impact as a range, at least one caveat, and the specific decision you are asking for.

Move any supporting charts or method notes into an appendix slide.

Rehearse out loud and time yourself; aim for three to five minutes. Then try giving the whole story in 60 seconds without slides.

Present to a friend, classmate or study group and ask them to repeat back your message and your ask.

## Why it matters

Analysts are often judged less by the quality of their analysis than by whether anyone acts on it. A correct finding buried on slide 14 changes nothing. A **data story** is a short, structured presentation that takes the audience from a question to a recommendation, with just enough evidence to trust it. It is not about drama or spin; it is about respecting the audience's time.

## Find the one message first

Before you open any slide software, finish this sentence in no more than two lines:

> "We should **[action]** because **[evidence]**, which will **[benefit]**."

For example: "We should add a delivery-time estimate to the checkout page because 38% of abandoned carts happen on the shipping step, and the stores that tested it recovered about a fifth of those carts."

Nancy Duarte and Cole Nussbaumer Knaflic both recommend this "big idea" step. If you cannot write it, your analysis is not finished, or you are trying to say too many things.

## A three-slide structure

For a short update (five minutes or less) three slides is enough:

**Slide 1: Context and question.** What situation are we in, and what question did we ask? Include one number that shows why it matters. "Checkout completion fell from 64% to 58% this quarter. We looked at where customers drop off."

**Slide 2: The key evidence.** One chart, decluttered, with a takeaway title that states the finding. "Most drop-off happens at the shipping step." Highlight the bar or line that proves the point. Put supporting detail in an appendix, not on this slide.

**Slide 3: Recommendation and next step.** The action, its expected impact (with a range if uncertain), what it costs, the caveats, and the decision you need from the audience. "Recommend: show delivery estimates at checkout. Expected: recover 15% to 25% of shipping-step drop-offs. Caveat: based on a two-week test in three stores. Decision needed today: approve a four-week A/B test."

This follows a classic arc: setup, conflict, resolution. It also follows the "answer first" pyramid principle: busy readers who only see slide 3 still get the message.

## Make each slide readable

- **Headline = the takeaway**, written as a full sentence.
- **One chart per slide**, sized large enough to read from the back of the room.
- **Highlight with colour**, grey the rest (Module 1).
- **Annotate**: add a short label directly on the chart at the point that matters ("Shipping step: 38% of drop-offs").
- **Numbers rounded** to what the decision needs: "38%", not "37.86%".
- **Speak to the chart, do not read it.** Say what to look at, then why it matters.

## Know your audience

- **Executives** want the answer, the impact and the decision needed. Lead with slide 3 if time is very short.
- **Technical peers** want method and caveats. Keep them in a backup slide and be ready to show it.
- **Mixed audiences**: main story for everyone, appendix for detail.

Ask in advance: how much time do I have, what do they already know, and what decision can they actually make?

## Be honest about uncertainty

Storytelling can slide into overselling. Protect your credibility:

- State sample sizes and time periods.
- Give ranges, not false precision.
- Say what the data cannot tell you ("this shows association; the A/B test will show cause").
- Do not cherry-pick a date range that flatters the result.

## Worked example: rehearsal checklist

Before presenting, run through:

1. Can someone who sees only the slide titles repeat the message?
2. Does every chart support the message on its slide?
3. Is there one clear ask?
4. Can you give the whole story in 60 seconds without slides?
5. Have you prepared answers for "how do you know?" and "what if you are wrong?"

## Common mistakes

- Walking through the analysis in the order you did it ("first I cleaned the data...").
- Several messages competing on one slide.
- Default chart titles such as "Funnel by step".
- No recommendation, just "interesting findings".
- Hiding caveats until someone asks.

## Quick recap

- Write the one-sentence big idea before building slides.
- Three slides: context and question, key evidence, recommendation and ask.
- Takeaway titles, one highlighted chart per slide, annotations, rounded numbers.
- Be clear about uncertainty; it builds trust.

## Try it

The **Do** tab has you build and present a three-slide data story from an analysis you have already done.


Structure a short data story around one message and one recommended action, and present it in three slides.

Presenting a data story

Telling Stories with Data in 3 Steps (Quick Study)

Data Storytelling 101 | Think Like a Data Analyst

Design a dashboard for one audience, build it in a free BI tool, and present a short data story that ends in a decision.

Data Visualization & Storytelling

About this course

Course content

Visual Principles

Charts in Python

Dashboards and Stories

Where this course leads

Next course on the path

Careers that use it