Case Study 1: The BBC's bbplot and Building a Data Journalism Brand

In 2019, the BBC's Data Journalism team released an open-source R library called bbplot. The library was a wrapper around ggplot2 that applied the BBC's visual style to any chart with a single function call. bbplot was not revolutionary in its technology — ggplot2 themes had existed for years — but it was revolutionary in its packaging. It turned the BBC's style from an internal convention into a reusable artifact that other news organizations could study, adapt, and use. The bbplot story is a case study in how a brand system can be codified as a library, and why that codification matters more than the style itself.

The Situation: Consistency at Scale in a Newsroom

The BBC produces hundreds of data visualizations per year across its news website, broadcast programs, and social media. Each chart is produced by one of a dozen or so journalists on the Data Journalism team, working under tight deadlines. Before bbplot, consistency was enforced by style guides and peer review — a style guide document specified the BBC's colors, fonts, and chart conventions, and senior journalists reviewed junior journalists' work before publication.

This worked, but it was inefficient. Every chart had to be reviewed for style compliance, which took time. Junior journalists forgot rules and had to look them up. Senior journalists had to correct the same mistakes over and over. The review process was a bottleneck, and inconsistencies still slipped through.

The team realized that the style could be encoded as software. If every chart started from a template that already applied the BBC's style, most of the review effort would be unnecessary — the style would be right by default. The only manual review would be for content and clarity, not for typography and colors.

The Implementation

bbplot was built as an R package by Nassos Stylianou, Clara Guibourg, and others on the Data Journalism team. The core of the package is a ggplot2 theme function:

bbc_style <- function() {
  font <- "Helvetica"

  ggplot2::theme(
    plot.title = ggplot2::element_text(family=font, size=28, face="bold", color="#222222"),
    plot.subtitle = ggplot2::element_text(family=font, size=22, margin=ggplot2::margin(9,0,9,0)),
    plot.caption = ggplot2::element_blank(),
    legend.position = "top",
    legend.text.align = 0,
    legend.background = ggplot2::element_blank(),
    legend.title = ggplot2::element_blank(),
    legend.key = ggplot2::element_blank(),
    legend.text = ggplot2::element_text(family=font, size=18, color="#222222"),
    axis.title = ggplot2::element_blank(),
    axis.text = ggplot2::element_text(family=font, size=18, color="#222222"),
    axis.text.x = ggplot2::element_text(margin=ggplot2::margin(5, b = 10)),
    axis.ticks = ggplot2::element_blank(),
    axis.line = ggplot2::element_blank(),
    panel.grid.minor = ggplot2::element_blank(),
    panel.grid.major.y = ggplot2::element_line(color="#cbcbcb"),
    panel.grid.major.x = ggplot2::element_blank(),
    panel.background = ggplot2::element_blank(),
    strip.background = ggplot2::element_rect(fill="white"),
    strip.text = ggplot2::element_text(size=22, hjust=0)
  )
}

This is a single function that sets every relevant ggplot2 theme element to match the BBC's style: Helvetica font, 28-point bold titles, 22-point subtitles, light gray horizontal gridlines only (no vertical), no axis ticks, no borders, legend at the top without a title. Apply with ggplot(...) + bbc_style().

The package also provides:

finalise_plot() function: takes a plot object, a title, a subtitle, a source attribution, and an output path, and saves the fully-formatted chart to disk at the correct dimensions for BBC web embedding. This function handles the "last mile" of chart production — aligning the title/subtitle, adding the source footer, embedding the BBC logo, and exporting at the right size. One function call replaces dozens of lines of ggplot2 formatting code.

bbc_colors: a named list of BBC colors. Journalists use bbc_colors$red` or `bbc_colors$blue instead of guessing hex codes.

Example scripts: the package includes a cookbook of example charts demonstrating how to produce each common type (line, bar, grouped bar, stacked bar, scatter, dumbbell, multi-panel). Each example is a working R script that a journalist can copy, modify, and use.

Documentation: README, chart-type guide, and inline function documentation. The package is designed to be discoverable — a new journalist can read the README and start producing branded charts within an hour.

The whole package is about 500 lines of R code. It is not technically sophisticated. What makes it successful is the packaging — turning a set of conventions into a library that other people can use.

The Open-Source Release

bbplot was released as open source in 2019 on the BBC's GitHub account. The decision to open-source was deliberate. The BBC wanted to share what they had built with the wider data journalism community, to contribute to the field, and to receive feedback and contributions.

The release was a success. Within a week, bbplot had thousands of stars on GitHub. Within a month, other news organizations had downloaded it, adapted it for their own brands, and started producing charts with bbplot-inspired styles. Within a year, bbplot was cited in data journalism curricula at universities, used as an example in R training courses, and discussed on conference panels.

The cascade effects:

Other organizations adapted it. Rather than building their own brand libraries from scratch, many news organizations started with bbplot and modified the colors, fonts, and rules to match their own identities. This was the original goal — bbplot as a reference implementation, not a monopoly.

R users learned the pattern. Data scientists who had not thought systematically about branding saw bbplot and realized they could do the same thing. The library demonstrated that encoding a brand as a library was feasible and desirable.

Python users copied the pattern. Since most data scientists use Python rather than R, Python versions of bbplot started appearing. Today there are several Python libraries inspired by bbplot, including matplotlib style sheets and seaborn wrappers.

Style guide discourse improved. Before bbplot, "having a visualization style guide" usually meant a Word document that gathered dust. After bbplot, the expectation shifted to "having a code library." This raised the bar for data teams that wanted to claim visual consistency.

Theory Connection: Packaging Beats Design

The bbplot case illustrates a specific claim: packaging matters more than design. The BBC's visual style (colors, fonts, conventions) existed before bbplot. It was in the style guide. Journalists followed it inconsistently. What bbplot did was not invent a new style but package the existing style as a reusable artifact.

This packaging was the breakthrough. Once the style was encoded in code, it was:

  • Reproducible: any journalist could apply it with one function call.
  • Auditable: the code made the rules explicit. No ambiguity about "what does the style guide say about gridlines?"
  • Versionable: changes to the style were tracked in git.
  • Shareable: the library could be distributed, forked, and modified.
  • Teachable: new journalists learned the style by reading the code, not by memorizing a document.

None of these properties came from the visual design itself. They came from the packaging. A beautifully-designed style guide in a Word document does not have these properties. A mediocre style packaged as code does.

The lesson generalizes: if you have a set of conventions — a visualization style, a data processing workflow, an analysis pipeline — packaging it as code is more valuable than documenting it as prose. The code enforces consistency, enables reuse, and becomes a teaching artifact. The prose gathers dust.

For Python practitioners, the equivalent of bbplot would be a package like mycompany-plot containing:

  • A matplotlib style sheet.
  • A Plotly template.
  • A helper module with branded_axes(), add_title(), save_branded(), etc.
  • A README with examples.
  • A gallery/ directory with working example scripts.
  • A tests/ directory with visual regression tests (optional but useful).

The package is installable via pip install mycompany-plot (or from a private registry). New team members install it once, import the helpers, and produce branded charts immediately. The package is the brand, and the brand is the package.

The Broader Pattern: Tools as Culture

The bbplot story is an example of a broader pattern: tools shape culture. Before bbplot, the BBC's data journalism culture was "style guide + peer review." After bbplot, it was "library + automatic compliance." The shift was not a change in values or priorities; it was a change in infrastructure that enabled the values to be realized more consistently.

This pattern repeats in other areas. Code review tools shaped the culture of software engineering. Version control shaped the culture of collaborative writing. Style checkers (linters, formatters) shaped the culture of Python code quality. In each case, a tool encoded a set of conventions, and the encoding made the conventions easier to follow than to ignore.

For data teams, the implication is that tooling investments have cultural payoffs. Building a brand library is not just a productivity improvement; it changes how the team thinks about visualization. Before, style was a chore that everyone had to remember. After, style is a tool that everyone uses. The cognitive load drops, the compliance rate rises, and the team's output becomes more consistent without anyone trying harder.

The bbplot example is specific — an R library for a UK news organization — but the principle applies anywhere. If your team has conventions worth following, encode them as tools. The encoding is the difference between aspirations and practice.

Discussion Questions

  1. On open-sourcing. The BBC chose to release bbplot as open source. What are the benefits and risks of this decision?

  2. On the packaging insight. The chapter argues that bbplot's success was about packaging, not design. Do you agree? Can packaging beat design?

  3. On Python analogues. What would a Python version of bbplot look like for your organization? What would be in the helper module?

  4. On cultural change. The chapter claims that tools shape culture. Give an example from your own experience where a tool changed how your team worked.

  5. On the style guide vs. library choice. If you had to choose between a style guide document and a library, which would you prioritize? Why?

  6. On your own team. Does your team have a brand library equivalent to bbplot? If not, what would it take to build one?

bbplot is a small open-source project that has had outsized influence on the data journalism and data science communities. Its lesson is that encoding conventions as code produces more consistent results than documenting them as prose. When you build a brand system for your own team, invest in the packaging — the code, the helper functions, the examples — not just the visual design. The packaging is what makes the design useable.