# Design System Examples: How to Read Real Systems as Models

> A tour of well-known public design systems, a close look at one button page, and a method for learning from them without copying them.

**In short:** Public design systems look different on the surface, but most are layered, with ideas at the top and working parts below, so you can read them as models.

From "Design systems", a free course by Venkat R. Murty: https://designervenkat.online/learn/design-systems/design-system-examples

## What you will learn

A design system is a shared set of parts and rules that a team uses to build its products. Many large companies publish their systems on the open web. You can read them to see what a real system contains, how it is arranged, and how it explains each part. In this lesson you will tour a few well-known systems, learn how a platform-wide system differs from a product system, walk through one button page step by step, and learn a method for studying any example critically. The goal is to read examples as models for your own work, not to copy them.

- **Design system:** A shared collection of parts, rules, and guidance that a team uses to design its products in a consistent way.
- **Principle:** A short statement of belief that guides design choices, such as putting the user’s task first.
- **Foundation:** A basic building material of the interface, such as color, type, spacing, and shape.
- **Component:** A reusable piece of interface, such as a button, menu, or dialog box.
- **Pattern:** A tested way several components work together to solve a common task, such as a settings page.
- **Variant:** A version of one component that looks or behaves a little differently, such as a main button and a quieter button.
- **Accessibility:** Making a design usable by people with disabilities, including people who use screen readers or keyboards.
- **Screen reader:** Software that reads the screen aloud for people who cannot see it well.
- **Versioning:** Labeling each release of a system so that users know which rules and parts they are using.

## What do real systems contain?

Public design systems look different on the surface, but most are arranged in similar layers. It helps to read them from the top down. The ideas sit at the top, the working parts sit below them, and the rules for using those parts sit beside them.

- **Principles:** The beliefs that shape every other choice. They are usually short, and they explain why the system asks for certain things.
- **Foundations:** The basic materials: color, typography (the type styles and sizes), spacing, layout, and shape. Teams reuse these so that every screen shares the same base.
- **Components:** Reusable parts such as buttons, text fields, menus, and cards. Each one usually has its own page with its options and rules.
- **Patterns:** Ways that several components combine to finish a job, such as a checkout step or a form with errors.
- **Usage guidelines:** Plain rules about when to use a part, when not to use it, how to word it, and how to make it accessible.

A design token is a named value, such as a specific blue, that is stored once and reused everywhere. Apple’s Human Interface Guidelines use a different structure. Apple has merged its platform-specific advice into one document and arranges it into components, technologies, design patterns, and foundational principles.

1. **Start with the principles:** Read the short beliefs first. They tell you why the rules below exist.
2. **Read the foundations:** Note the basic materials and how much room the system gives you to change them.
3. **Open one component page:** Look at how the page is laid out: purpose, options, examples, and rules.
4. **Check the patterns:** See how components are combined to finish a whole task, not just one step.

> **Tip:** Reading in this order keeps you from memorizing parts without knowing their purpose. A button rule makes more sense once you know the principle behind it.

## A quick tour of four systems

The four names below are the ones most often used as examples. Three of them are described from pages read for this lesson. Carbon and Atlassian are included because they are common reference points, but this lesson does not describe their contents. Use the same reading checklist on their official sites before you draw conclusions about them.

### Material Design 3

Its component pages cover items from menus to buttons to dialogs.

> **Tip:** Material is a good place to see a very complete system. Notice how much of it is foundations and rules, not just finished parts.

### Apple Human Interface Guidelines

Apple’s Human Interface Guidelines, often called the HIG, are guidance for designing apps across Apple platforms. Commentators commonly summarize its core principles as clarity, deference, and depth. Apple calls the HIG a living document, which means it changes as new devices and technologies arrive.

Apple also explains that the guidelines cover design approaches, components, technologies, and patterns, with links to videos and reference pages on each page. That layout makes it easy to move from a principle to a working example.

### Shopify Polaris

Polaris is Shopify’s design system. Its web components are used to build apps for Shopify merchants, and they follow Shopify’s design system so that apps look and feel like part of the Shopify admin. The documentation lists components by job, such as actions (buttons), forms, and more. Each component page includes its options, its uses, and its code sample.

Polaris also shows how systems change. The npm package page says the older React version of Polaris is deprecated and no longer maintained, and the docs offer several versions to choose from. That is why versioning matters: a team must know which release its rules describe.

> **Tip:** Always check the version of an example. A rule from an old release may no longer match the current parts.

## What is the difference between platform systems and product systems?

Not every design system serves the same audience. Some are written for a whole platform, and others are written for one company’s product. The difference changes the scope of the rules and the tone of the writing.

- **Platform-wide systems:** Material and Apple’s HIG are written for many kinds of apps on many kinds of devices. Their tone is general and teaching-oriented, because readers may be building almost anything.
- **Product or company systems:** Polaris is written for apps that run inside one product. Its scope is narrower, and its rules fit that product’s users and tasks.
- **What changes for you:** A platform system tells you how to behave like a good citizen of a device. A product system tells you how to fit into one specific workflow. A small team usually needs the second kind of thinking.

> **Tip:** Before you borrow any rule, ask who the system was written for. A rule that suits a whole platform may be too broad for a single app.

## Worked example: the Polaris Button page

Now look closely at one component. The Polaris Button page is a good example because a button is simple to understand, yet its page covers many decisions. Follow these steps as if you were studying the page on your own screen.

1. **Read the purpose:** The page says a button triggers actions, such as submitting a form, opening a dialog, or going to another page. It also says that for links inside a sentence, you should use the link component instead, and that related buttons are grouped with the button group component. The first lesson is that a button is for doing something, not for simple navigation in text.
2. **Compare the variants:** The page lists four options for the variant setting: automatic, primary, secondary, and tertiary. Its use-case list says primary buttons suit main actions such as saving changes, and secondary buttons suit supporting actions such as cancel, reset, or viewing details. The tertiary option is listed, but read its own notes before you use it. Do not assume its meaning from the name.
3. **Choose a tone:** Tone is a separate setting. The options are automatic, neutral, and critical. The page describes critical as the tone for urgent problems or destructive actions. So a delete button may use the critical tone, while a save button usually does not need it.
4. **Study the states:** The page explains the disabled setting, which stops a button from being clicked or focused. It also explains the loading setting. Loading replaces the button text with an indicator while work happens in the background, and it also disables the button. That prevents people from pressing it twice.
5. **Read the do and don’t advice:** The official page I read did not show a full do and don’t section. A community port of the Polaris button guidance does.
6. **Check the accessibility note:** The page includes an accessibility label setting. It describes the purpose of the button for assistive technologies, such as screen readers. The guidance is to use this label when the visible text alone does not explain the purpose clearly. For example, a button that only shows an icon needs a label a screen reader can announce.
7. **Read the properties as design options:** The page pairs its list of properties with a short sample of markup. As a designer, you do not need to write that sample. Instead, read the properties as the choices a team can make for each button, and note which ones the system chooses for you.

> **Tip:** This page shows the pattern you should look for in any system: purpose first, then options, then rules, then accessibility. If a page skips one of these, note the gap before you copy it.

## How do you study an example critically?

Reading a system is different from reading a story. You are looking for reasons, edges, and gaps. Four things are worth checking on almost every page.

- **Clear do and don’t guidance:** Good pages show a right way and a wrong way, and they explain the difference. If a page only shows good examples, you learn less about the edges.
- **Accessibility notes:** Look for labels, contrast advice, keyboard behavior, and notes for screen readers. These details are easy to skip, but they decide whether many people can use the part at all.
- **Code alongside design:** Some systems show the design and the matching code side by side. You do not need to read the code to benefit. Use it to see which options exist and which ones the design must respect.
- **Versioning:** Check which release the page describes, when it was last changed, and whether an older version is still listed. Rules shift over time, and a page can be correct for one version only.

After you spot these things, decide what to borrow. Borrow the way a system is organized, such as principles first and one page per component. Borrow the do and don’t pairs, the accessibility habits, and the habit of naming variants by their job rather than their color. Do not borrow the company-specific parts: brand colors, a store’s branding rules, a platform’s navigation style, or a product’s specific workflows. Those belong to the company that made them.

> **Tip:** Ask why a rule exists before you copy it. If you cannot name the problem the rule solves, you are not ready to reuse it.

## Test yourself

Use the three short scenarios below. Each one needs the ideas from this lesson, not just a memory of the text above.

**Quick check:** A small startup has one app and three designers. It wants its first design system. Should it copy Material Design’s full structure, or take a lighter approach inspired by Polaris or Atlassian? Which plan fits best?

A. Copy Material Design’s full structure, including every foundation and component, so the app looks as complete as the big systems.
B. Start light: write a few principles, pick basic foundations, document the handful of components the app really uses, and borrow the one-page-per-component layout from Polaris.
C. Skip written rules and let each designer decide from memory, because a small team does not need documentation.
D. Wait until the app has many products before writing anything, so the system can be designed all at once later.

**Answer:** B. A platform-wide system is built for many kinds of apps and devices. A single app needs a smaller set that fits its own tasks. Borrowing the structure and the documentation habits gives the team clear rules without the cost and scope of a full platform system. Copying everything would import parts the team does not use, and skipping written rules would leave the three designers to disagree.

**Quick check:** A team is designing a new settings page with two buttons: Delete account, which cannot be undone, and Cancel. A designer makes both buttons red so that both stand out. Based on the Polaris button guidance, what should the team change?

A. Make both buttons red, because equal emphasis helps people see every option.
B. Keep Delete red, because the action cannot be undone, and give Cancel a plainer, supporting style instead.
C. Turn Delete into a text link inside the page, because links look less serious than buttons.
D. Remove the Cancel button, so that people have only one choice on the page.

**Answer:** B. Using a link for a destructive action hides its seriousness, and removing Cancel takes away a safe choice.

**Quick check:** You are studying a button page from an unfamiliar system. It shows many good examples, but it says nothing about accessibility labels or screen readers. What is the most useful next step?

A. Assume the system has no accessibility rules at all, and stop studying it.
B. Look for accessibility notes elsewhere in the system, such as a foundations or accessibility section, and check whether the component page links to them before you decide how to use the button.
C. Copy the examples exactly, because good-looking examples are enough to build a safe product.
D. Ignore the page’s version, since accessibility rules never change between releases.

**Answer:** B. A missing note on one page does not always mean the rule is missing from the whole system. A careful reader checks related sections before deciding. Copying examples without the rules can produce parts that some people cannot use, and version information matters because guidance can change.

## Summary and next steps

Real design systems follow a shape you can learn. They begin with principles, build on foundations, offer components and patterns, and explain their use with plain guidelines. Platform systems such as Material and Apple’s HIG cover wide ground, while product systems such as Polaris fit one product tightly. The Polaris Button page shows how one part can be documented with variants, tones, states, and accessibility notes. When you study any example, look for those same layers, check the version, and borrow the method rather than the look.

> **Tip:** Pick one system you use every day, read one component page from start to finish, and write down three things you would borrow and three you would leave alone.

## Sources

- [Material Design 3: Get started (official Material site)](https://m3.material.io/get-started)
- [Android Design Guidelines guide (CodePath, describing Material Design 3)](https://guides.codepath.org/android/Android-Design-Guidelines)
- [Meet the new Human Interface Guidelines (Apple Developer news)](https://developer.apple.com/news/?id=v8a3aetj)
- [iOS Human Interface Guidelines explainer (Netguru)](https://www.netguru.com/blog/ios-human-interface-guidelines)
- [Polaris Button component docs (Shopify developers, latest version)](https://shopify.dev/docs/api/app-home/latest/web-components/actions/button)
- [Polaris web components overview (Shopify developers)](https://shopify.dev/docs/api/app-home/latest/web-components)
- [Using Polaris web components (Shopify developers)](https://shopify.dev/docs/api/polaris/using-polaris-web-components)
- [Polaris package page (npm, notes that Polaris React is deprecated)](https://www.npmjs.com/package/@shopify/polaris)
- [Polaris Vue Button page (community port that mirrors Polaris button guidance)](https://ownego.github.io/polaris-vue/components/Button)
