Marcus Andrey Study
Ler em português Library

Design Systems · Step 4 · 6 min read

From components to patterns

Components are the parts; patterns are how the parts solve a task. What a pattern is in a design system, how Harbour's "Book a crossing" pattern is built from eight components, what a pattern's doc page needs, and why patterns change more slowly than components.

Five tiles lying loose on a tray around a dashed footprint: a header strip, an image, two blocks of text and a button. Bring the pointer toward the middle and the tiles draw in, until they sit edge to edge as one card; move away and they drift apart again. That's this step: a pattern is components put together the same way every time, for one job. This step has three lessons: from components to patterns, content and voice in the system, and icons and illustration in the system.Illustration: Marcus Andrey, drawn with Hairline (MIT, Lucas Marques).

A box of perfect bricks doesn't tell you how to build a house. Harbour can have an accessible Button, a careful Text field and a Ticket card that survives every edge case, and two teams can still build booking flows that work in opposite ways. Patterns are the part of the system that says how the parts go together for a task people do again and again, and why that way.

What you'll be able to do after reading:

  • Tell a pattern from a component and from a template
  • Describe a pattern as a task, the components it uses and its rules
  • Write a pattern's doc page with the evidence behind it
  • Decide which of your product's flows deserve to become patterns

1. What a pattern is

Two public systems put it well:

  • The GOV.UK Design System: "Patterns are best practice design solutions for specific user-focused tasks and page types." And: "Patterns often use one or more components and explain how to adapt them to the context" (GOV.UK, Patterns).
  • IBM Carbon: patterns "help users achieve goals through reusable combinations of components, templates, flows, and sequences", and "differ from components, which are already designed, coded, and ready to be imported into a UI" (Carbon, Patterns).

So a component is a thing you import. A pattern is a way of doing something, and it's often a page of guidance with examples rather than a single piece of code. In Brad Frost's terms from What a design system is, patterns live where organisms become templates; but the useful test is simpler: a component answers "what is this?", a pattern answers "how do people do this task?"

Component Pattern
Unit One piece of interface A task or a page type
Example Text field, Button Book a crossing, Ask for a date, Empty state
Delivered as Code and a Figma component Guidance, examples, sometimes a template
Changes when Its design or API changes Research shows a better way to do the task

2. A pattern, assembled

  1. Where are you going?

    FromKestrel BayToMara IslandContinue

    Port picker × 2 · Button

  2. When?

    Date4 / 12 / 2026Continue

    Date field · Button

  3. Who's travelling?

    Surname, passenger 2Enter the surname of passenger 2Continue

    Text field · Error summary · Button

  4. Check your booking

    Kestrel Bay → Mara Island · 09:40 · 2 adultsChangePay €38

    Summary list · Button × 2

  5. Booked

    On timeYour ticket is in the app and in your email.Show ticket

    Ticket card · Badge

Problem
People need to buy a crossing on a phone, often on the move, sometimes for others.
When to use
Any purchase of a sailing: booking app, and the staff console's phone bookings.
When not to
Changing an existing booking: use the Change booking pattern, which starts from the ticket.
Rules
One question per screen. Check before paying. Errors next to the field and in a summary at the top.
A pattern is a solution to a task, built from components. "Book a crossing" uses eight Harbour components in five screens, and its doc page explains the order, the rules and why. The question-per-screen and check-answers ideas come from the GOV.UK Design System's patterns.

"Book a crossing" is Tidewater's most important task. The pattern says:

  • One question per screen. GOV.UK's question pages pattern: "Asking just one question per question page helps users understand what you're asking them to do" (GOV.UK, Question pages). On a phone, on a windy pier, that's even more true.
  • Check before paying. GOV.UK's check answers pattern puts a single check page "immediately before the confirmation screen" (GOV.UK, Check answers). Harbour's version uses the Summary list, with a Change link per answer.
  • Errors next to the field and at the top, using the Text field and the Error summary from the last lessons. See Forms for the basics.
  • The confirmation is the ticket itself. The last screen shows the Ticket card, not a "success" message, because what people want after paying is the thing they paid for.

None of those rules belongs to a single component. That's exactly why they need a pattern.


3. The pattern's doc page

A pattern page answers the questions a designer has when they start a flow. Harbour's template:

  1. The task and the problem, in a sentence: who, doing what, where.
  2. When to use it, and when not to. "Changing a booking" looks similar and isn't: it starts from the ticket.
  3. How it works: the steps, as in the figure, with the components each step uses.
  4. The rules, each with its reason.
  5. The evidence: research, analytics, support tickets. "Abandonment at the passenger step fell after we split it into one passenger per screen" is worth more than any opinion.
  6. Variations: the staff console books by phone, with the same steps in one dense screen.
  7. Examples in production, with links, so people can see it working.

The evidence part is what makes a pattern different from a style preference. A pattern is a claim that this way works better for this task, and it should say why you believe it. Patterns and when to break them covers the other side: when a product has a good reason to do something else.


4. Which flows become patterns

Not every flow deserves a page. Harbour's rule of thumb: a flow becomes a pattern when two or more products need it, or one product does it in more than one place. That gives three kinds:

  • Task patterns: book a crossing, change a booking, add a vehicle, sign in.
  • Page types: empty states, error pages, the "sailing cancelled" interruption.
  • Interaction patterns for the console: bulk actions on a passenger list, filtering a long table, keyboard shortcuts.

Start with the task people do most, and with the one where teams disagree the most. The interface inventory from The interface inventory shows both.


5. Patterns change slowly, on purpose

Components change with design and code: a new variant, a token update, a bug fix. Patterns should change when you learn something about the task. That's slower, and it should be. If "Book a crossing" changes every quarter, people stop trusting it.

Treat a pattern change like a breaking change in a component: announce it, explain the evidence, give teams time (Deprecation and breaking changes). And keep the old version visible in the changelog, so people understand why their flow looks different from the new one.


6. Common mistakes

  • Calling a big component a pattern, or a page template a component.
  • Pattern pages with rules but no reasons or evidence.
  • Patterns copied from another system without checking they fit your users.
  • Every flow documented as a pattern, so nobody finds the important ones.
  • Changing a pattern without telling the teams who use it.

7. Vocabulary

Term Meaning
Pattern A reusable solution to a task or a page type, built from components
Task pattern A pattern for something people do: book, pay, sign in
Page type A kind of page with a known job: empty state, error page, confirmation
Template A page layout with components placed, without real content
Recipe A fixed arrangement of components in one product (see Composition over configuration)
Evidence Research, data or support findings that show why a pattern works

8. Try it (no tools needed)

  1. Pick a task you've done in two different apps this week: paying, booking, signing up.
  2. Write the steps each app used, and the components on each step.
  3. Write one rule both apps followed, and one where they disagreed. Which worked better for you, and why?

Reflection questions: Which task in your product is built differently by different teams? What evidence would settle which way is better?


9. If you already practise

  • Add an evidence section to every pattern page, even if today it only says "no research yet".
  • Link each pattern to the analytics or the research that supports it, and review it once a year.
  • Keep a short list of candidate patterns from the inventory, ranked by how often the task happens.
  • Ask product teams to report where they broke a pattern and why; three similar reports are a signal to change it.

Checklist

Learn more

Books, courses and videos to go deeper

Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.

Accessible components · Content and voice in the system · Patterns and when to break them · Forms · The interface inventory · Composition over configuration · Component docs people use · Pattern tiers · Atomic design

Saved only on this device.

↑ ↓ to move · Enter to open · Esc to close