Book a call

WritingBuilding a systemPart 1 of 4 in Patterns and content

Design system patterns: when components aren't enough

Every team uses the same button, field and table, and the product still feels like five products. Components are the words; patterns are the sentences. What patterns are, which ones to write down first, and how to document them.

On this pageComponents are words, patterns are sentences
  1. Components are words, patterns are sentences
  2. Pattern or component?
  3. The four pattern families to start with
  4. How to document a pattern
  5. When to write a pattern down
  6. The short version
  7. Frequently asked questions
  8. Further reading

The short answer

A design system pattern is a documented way of combining components to solve a recurring user problem, such as "how we show that there are no results" or "how we confirm a destructive action". Components are the words; patterns are the sentences. A system with good components and no patterns still produces inconsistent products, because every team combines the same parts differently. Start with the four pattern families that cause most inconsistency: forms, lists and tables, navigation and feedback (loading, empty, error and success).

  • A pattern isn't a new component. It's guidance, with the reasoning and evidence behind it.
  • Document a pattern when two or more teams have solved the same problem differently.
  • Patterns need documentation even more than components, because there's no code to copy: the guidance is the pattern.

Components are words, patterns are sentences

You can have a perfect dictionary and still write confusing sentences. Design systems have the same problem. Every team uses the system's button, text field and table, so the components are consistent. But each team combines them differently: one form shows errors at the top, another under each field, a third in a pop-up. One list paginates, another scrolls forever. The parts match and the product still feels like five products.

An illustration: four ways to say "nothing here"

The situation

A customer searches invoices, filters payments, opens an empty report and views a new project. Every component on those screens comes from the design system.

What they see

"No data", a blank white area, a sad-face illustration with "Oops!", and "0 results found" in small grey text. Four teams, four answers to the same question.

What a pattern changes

One documented empty-state pattern with three versions (first use, no results, all done), each with a clear message and a next step. Same components, now saying the same thing.

New word

A pattern is a proven, documented way of combining components to solve a recurring user problem. The UK government's GOV.UK Design System is the best-known public example: alongside its components it publishes patterns for asking for dates, addresses and names, each based on research with real users.

PatternsHow components combine to solve a problem: "validate a form", "show no results", "confirm a deletion". Guidance, examples and evidence.
ComponentsThe reusable parts: button, text field, table, dialog, toast. Code and design, with props and states.
Foundations and tokensColour, type, spacing and layout as named decisions every component inherits.
Where patterns sit. Patterns are built from components, which are built from tokens. Each layer only makes sense once the one below it is settled.

Pattern or component?

Teams often ask for a new component when what they need is a pattern, and the other way round. A quick test helps:

If the request is…It's probably a…Example
A new visual element with its own states and behaviourComponentA stepper, a file uploader, a segmented control
A way of arranging existing components for a taskPatternA filter bar built from fields, selects and chips
A rule about when to use one component over anotherPattern"Toast for confirmations, banner for account-wide warnings"
A flow across several screensPatternSign-up, checkout, onboarding a new team member
The same arrangement copied into many products, with codePattern first, then maybe a componentAn empty state used everywhere may earn its own component later
Most "we need a new component" requests at a mature system are really pattern requests. The parts exist; the agreement about how to use them doesn't.

The four pattern families to start with

You don't need a hundred patterns. Most of the inconsistency in business software comes from four families, and writing down one answer for each removes most of the re-debating between teams.

FORMS

Where products make money

Layout, required fields, when to check for errors, where to show them, what they say, long forms and buttons. Usually the first pattern worth writing down. See form design patterns.

LISTS AND TABLES

Where people find things

Table, list or cards; pagination or "load more"; how filters, search, sorting and bulk actions work across the product.

NAVIGATION

Noticed only when it fails

The app frame, side menu or top navigation, tabs, breadcrumbs and back links, and the rules for when each is right.

FEEDBACK

Where products feel inconsistent

Loading, empty, error and success states. Each team handles them as an afterthought, so they drift the most.

Lists and tables: three choices to make once

Most business software is a collection of lists: invoices, customers, orders, users. How people find, sort and act on items decides how fast they work.

TABLE

When people compare

Many items with the same attributes, where people scan columns, sort and compare: invoices, transactions.

LIST

When people pick

Items with one or two key details, where people mostly find one and open it: messages, notifications.

CARDS

When items are visual

Where an image or preview matters more than comparison: templates, projects, products.

ApproachBest forDownsides
PagesWork tools where people need to find their place again or reach the endExtra clicks; page size choice matters
"Load more" buttonFeeds and search results where people mostly look at the first fewLong pages; footer hard to reach after loading lots
Endless scrollingBrowsing with no particular goalHard to return to a spot; footer unreachable; heavy for keyboard and screen reader users
Pagination choices. Practitioner view For work tools, pages are usually right; endless scrolling rarely is.

For filters, decide where they sit (above the list or in a side panel), whether results update instantly or after "Apply", how active filters are shown and cleared, and what the empty result says. For bulk actions, decide how people select many items and where the actions appear. Written once, these decisions stop every list in the product from working slightly differently.

Navigation: one job per component

ComponentUse it forDon't use it for
Side menuThe main sections of an app with many areas (five or more)Actions; settings for the current page
Top navigationA few main sections, often on websitesDeep hierarchies
TabsSwitching between views of the same thing (an invoice's details, payments, history)Moving between different areas of the app
BreadcrumbsShowing where you are in a deep hierarchy and stepping back upFlat products with one or two levels
Back linkReturning from a detail page or a step in a flowReplacing the browser's own back button
Practitioner view

If people need to go more than three levels deep (section, page, tab) to reach something they use often, the problem is usually the structure of the product, not the navigation component. That's a conversation for product leadership, and the design system team is often the first to notice it.

Feedback: four moments, four components

Every screen has moments when things aren't normal: data is loading, there's nothing to show, something went wrong, or something just succeeded. Decide once which component carries each kind of message.

Inline messageAbout one field or section. "Enter a full email address."
→
ToastA short confirmation it's fine to miss. "Invoice sent."
→
BannerAbout the whole page or account; stays visible. "Your trial ends in 3 days."
→
DialogA decision people must make before continuing. "Delete this customer and 12 invoices?"
From least to most interruptive. Choose the least interruptive component that still gets the message across; reserve dialogs for decisions.
FIRST USE

Nothing yet

Explain what will appear and offer the first step: "No invoices yet. Create your first invoice to get paid faster."

NO RESULTS

Search found nothing

Say what was searched, and suggest changing or clearing the filters.

ALL DONE

Everything is cleared

A small, positive confirmation: "All invoices are paid." No action needed.

For loading, show a skeleton for short waits so the page doesn't jump, show progress on the button that was pressed for actions like saving, and always handle the case where loading fails, with a clear way to try again.

How to document a pattern

A component page can lean on live code examples. A pattern page can't: the words are the pattern. A consistent template makes patterns quick to write and easy to trust.

PatternsConfirm a deletionEmpty statesError summaryFiltersLong formsNavigationLoading
1The problemWhat people are trying to do, in one or two sentences.
2The solutionWhich components are used, in what arrangement, with a diagram.
3ExamplesReal screens from your products: good ones, and ones to improve.
4VariationsApproved versions for different situations, such as a short form and a long one.
5When not to use itSituations where a different pattern fits better.
6EvidenceResearch, test results or analytics that support the approach.
7Accessibility and writingKeyboard flow, announcements, and the words to use.
A pattern page template. Sections 1 and 2 answer the question people arrive with; section 6 is what stops the pattern being re-debated every quarter.

The evidence section matters more than it looks. Without it, a pattern is one team's preference, and the next team with a different preference will argue. With it ("we tested inline errors against a top summary with eight users; both were needed"), the conversation moves on.

When to write a pattern down

  1. Notice the second solution

    When a second team solves a problem the first team already solved, differently, that's the signal. The same "rule of two" that decides when something joins the core library applies to patterns.

  2. Collect every existing version

    Screenshot each team's solution side by side. Seeing four empty states on one board usually ends the debate about whether a pattern is needed.

  3. Agree one answer, with evidence

    Pick or design the best version with the teams involved, and test it if the stakes are high. A short working group of three to six people works well.

  4. Document it with the template

    Problem, solution, examples, variations, when not to use it, evidence, accessibility and writing.

  5. Migrate the most visible versions

    Update the screens people see most first. The rest follow as teams touch them.

In practice

At JPMorgan Chase, shared design patterns are used by product teams across the company, with a workflow where an AI agent does the early research and drafts each pattern for designers to review. See the project.

The short version

  • Components are words; patterns are sentences. Consistent parts still need agreed combinations.
  • Start with forms, lists and tables, navigation, and feedback states.
  • Write a pattern down when a second team solves the same problem differently.
  • Use one template: problem, solution, examples, variations, when not to use it, evidence, accessibility and writing.
  • Evidence is what stops a pattern being re-debated.

Frequently asked questions

What is the difference between a pattern and a component in a design system?

A component is a reusable part with its own code, design, props and states, like a button or a dialog. A pattern is guidance on how to combine components to solve a recurring problem, like validating a form or showing that there are no results.

Do patterns need code?

Not necessarily. Many patterns are guidance plus examples. When a pattern is copied into many products with the same code, it can be worth turning into a component or a copyable recipe later.

Who should own patterns?

The system team owns the library of patterns, but individual patterns are often written by the product team closest to the problem, through the normal contribution process, and reviewed by the system team.

How many patterns does a design system need?

Fewer than you think. Start with the four families (forms, lists, navigation, feedback) and add patterns only when two or more teams need the same answer.

Further reading