# Performance: How Design Choices Keep Design System Parts Fast

> Learn how images, fonts, icons, and motion slow a product, how budgets keep them in check, and how loading design makes waiting feel shorter.

**In short:** Design system performance is how images, fonts, icons and motion affect speed, kept in check with budgets and loading design that makes waiting feel shorter.

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

## What you will learn

Performance is how fast and smoothly a product loads, and how quickly it reacts when someone taps or clicks. In a design system, performance also covers how shared choices such as images, fonts, icons, components, and motion change that speed for real people. Designers cannot write the code that loads a page, but they make choices that make it heavier or lighter. This lesson shows how to make light choices and how to set limits the whole team can follow.

You will learn three ideas. First, every design decision has a cost in load time. Second, a well-designed wait can feel shorter, even when the clock says the same. Third, one shared component can speed up or slow down every screen that uses it. A worked example and a short quiz finish the lesson.

- **Performance:** How quickly and smoothly a product loads and responds to what a person does.
- **Load time:** The time between a visitor opening a page and being able to use it.
- **Asset:** Any file a screen needs, such as a photo, a font file, an icon, or an animation.
- **Page weight:** The total size of the files a page must download before it looks finished.
- **Performance budget:** A written limit on how much weight or delay a page or part may add, such as a maximum number of font weights.
- **Font weight:** One thickness of a typeface, such as regular or bold. Each weight is usually its own file.
- **Component:** A reusable building block, such as a button, a card, or a header, that many screens share.
- **Lazy loading:** Waiting to download an image until the reader is close to seeing it.
- **Skeleton screen:** A grey, shaped placeholder that shows where content will appear while it loads.
- **Perceived performance:** How fast a wait feels to the person, which can differ from the real clock time.

## What speed cost does every design choice have?

A design file looks weightless, but the files behind it are not. Each photo, font file, icon set, shadow, and animation must reach the phone before the screen is ready. Small choices add up, and the team often does not notice until the product already feels slow. Most slow products are not ruined by one bad decision. They gain weight through ordinary additions such as another font, a larger hero image, a chat tool, or a new component library.

- **Images:** Large photos are often the heaviest part of a page. A photo that is far bigger than the space it fills still has to be downloaded in full. Designers can export images at the size they will be shown and pick different crops for phones and desktops.
- **Fonts:** Every font weight is a separate download. One source gives file sizes of roughly 80 to 180 KB for a single regular weight of Inter as WOFF, and 150 to 300 KB as TTF or OTF. KB means kilobytes, a small unit of file size. Fewer weights means fewer files to fetch.
- **Icons:** Large icon sets and extra icon libraries add files for a few small pictures. One guide suggests a single icon file that holds only the icons in use, instead of several libraries for a handful of symbols.
- **Shadows and animations:** Animation libraries can add hundreds of kilobytes on their own. Motion that only fades or slides an element is cheaper for a phone than motion that forces the whole page to be laid out again on every frame.

The common thread is that every choice spends from the same pool. A video in the hero leaves less room for everything else on the first screen.

> **Tip:** When someone proposes a new heavy element, ask what it will replace. A speed plan works best when new weight must displace something old.

The next part shows how teams keep this pool under control with a written budget.

### How do you set a budget the team can follow?

A performance budget turns a wish like keep it fast into numbers people can check. It is agreed before the visual work starts, not added after launch. Think of it as a shared contract between design, brand, and the people who build the product. One source calls it a design constraint, not a surprise discovered after launch.

1. **List what a screen loads:** Write down the groups of files a screen needs: hero images, font files, icons, animations, and third-party tools. A third-party tool is code from another company, such as a chat box or an analytics tag.
2. **Set a limit for each group:** Give each group a maximum. One guide suggests two font families as a sensible cap for many sites, and another lists a starter cap of under 150 KB for the largest image on a page. These are examples to start a discussion, not universal standards. Test them on real phones and connections before you trust them.
3. **Name an owner:** Each limit needs a person who answers for it. For example, a typography lead might own the font limit, and an image lead might own the photo limit.
4. **Check the real output:** Before approving a screen, look at the delivered image at real phone and desktop widths. Do not judge the file only in the design tool.
5. **Decide what gives when a limit is hit:** If a team wants a video, a font weight or a script must be removed or reduced. Naming the trade-off in the review keeps the budget honest.

> **Tip:** Keep the budget next to the brand rules and show it in design reviews. A budget that nobody reads or runs is only decoration.

## Why does perceived speed matter as much as real speed?

Real speed is what a clock or a test measures. Perceived speed is how long a wait feels to a person. The two are different. Two screens can take the same time to load, yet one feels faster because the person can see something happening. Designers shape perceived speed with loading states, progress indicators, and instant feedback.

Waiting feels longer when a person is unsure what will happen. Showing progress, or the shape of the content to come, reduces that uncertainty and makes the same wait easier to bear.

- **Skeleton screen:** A grey placeholder that copies the layout of the content. It shows where a list, card, or profile will appear. It works best when the layout is predictable.
- **Spinner:** A spinning icon that says something is loading but not how long it will take. Spinners suit short, unpredictable actions, such as pressing a button or submitting a form.
- **Progress indicator:** A bar or step counter that shows how far along a task is. It helps most when the system can estimate what work is left.
- **Instant feedback:** A quick visible response to a tap, such as a button changing shape, shows that the product heard the person. The full result can take longer, but the screen never feels frozen.

Some teams go further with optimistic UI. For low-risk actions, the screen shows the expected result straight away and confirms it in the background. A person saving a draft rarely needs to wait for a confirmation before continuing.

Designers should not assume a skeleton always helps. One source notes that whether a skeleton improves perceived speed should be measured for each project. Another stresses that a generic grey box used for every content type is a common mistake.

### How do you define loading patterns once as reusable parts?

A loading pattern should be a named part of the design system, the same way a button is. If every team draws its own grey boxes, the product will show many different waits. A skeleton can be a variant of a card, so any screen that shows a card gets the same placeholder shape.

1. **Choose the right indicator:** Use skeletons for content with a known structure, such as lists, cards, and profiles. Use spinners for short actions, such as a button press.
2. **Match the real content:** The placeholder should copy the layout and size of the real content, so the page does not jump when the content arrives.
3. **Stay selective:** Do not turn every element into a placeholder. Mark only the regions that are waiting, so the rest of the page still feels stable and ready.
4. **Plan the failure case:** A shimmer that loops forever can hide a failed request. Define what the screen shows after an error or a timeout.
5. **Write it into the guidelines:** Record the pattern, its variants, and when to use each one, so every team picks the same option for the same kind of wait.

> **Tip:** Keep placeholders light. Simple shapes cost a device less effort than detailed illustrations, and they are enough to set expectations.

## Why do shared components multiply the impact?

A design system reuses its parts. That means a choice made inside one shared component appears on every screen that uses it. One optimized component speeds up the whole product. One heavy component slows the whole product in the same way. Designers should treat each core component as a multiplier, for good or for harm.

- **Lazy-loaded image:** A card that waits to load its photo until the reader scrolls near it. Every list that uses the card gets the saving.
- **System or subset fonts:** A system font is one already on the device, so it needs no download. A subset font keeps only the characters the product uses. Any text style built on either choice benefits on every page.
- **Shared icon set:** One icon file that holds only the icons in use, reused by buttons, menus, and lists. This avoids a new icon library for every team.
- **Reusable styles:** Colors, spacing, and type values written once and referenced by many components. One decision updates many places, and the same value is not repeated in many files.

The reverse is also true. A heavy video in a shared hero, or an extra animation library inside a core header, slows every page that uses it. Some teams have seen slow sites grow from many small parts, such as a component library, an extra font, and a chat widget. That is why performance should be checked when core components are built, not after dozens of screens depend on them.

The next part explains how to make that check routine.

### When should you check performance for core components?

1. **Pick the core parts:** Start with the parts most screens use, such as buttons, cards, navigation, and the page header.
2. **List what each part brings in:** Note every image, font, icon, and motion effect the part needs to appear and work.
3. **Compare with the budget:** Check each part against the limits your team agreed, such as the font count and the largest image size.
4. **Test in a real layout:** Look at the part inside a real screen on a mid-range phone and on a slow connection. An empty test file hides the real cost.
5. **Recheck every change:** Each new variant or added effect is a new check. Update the record each time, so the budget stays true.

> **Tip:** A component's weight is paid on every page that uses it. Before adding a motion effect to a button, ask whether it is worth that cost on every screen.

## Worked example: a news article page

Imagine a news site whose article page opens with a full-width hero photo of about 3 MB. The page also uses five weights of its typeface. On a phone, the main content appears slowly. A designer who works with the system in mind can fix this without changing how the page looks.

1. **Find the heaviest item:** The designer checks the page's files and finds the 3 MB hero photo. It is the largest single asset, so it is the first thing to fix.
2. **Export a smaller version for each screen:** The photo is compressed and sized to the width a phone needs. A larger version can serve desktops, so no device downloads more than it needs.
3. **Show a light placeholder first:** The compressed hero sits behind a lightweight placeholder, so the frame is in place from the start. Photos further down the article use lazy loading and only download as the reader scrolls toward them.
4. **Trim the typeface from five weights to two:** The designer keeps one regular weight for body text and one bold weight for headings. Hierarchy can also come from size, so extra weights are needed only when a real screen requires them.
5. **Check the result:** The designer compares the page on a phone before and after. The look stays the same, but the page downloads less and shows its content sooner.

> **Tip:** Reserve the space for the photo before it arrives. Without a reserved space, the text jumps down when the picture appears, which feels slow even when it is not.

The designer then writes the decisions into the system: an image component with a placeholder and a lazy-loading rule, and a type scale that allows two weights. Now every article gets the same benefit without anyone repeating the work.

## Check your understanding

**Quick check:** Your team's product page feels slow on mobile. A teammate proposes a new custom font in four weights and an autoplay background video in the hero. Which two design-side changes would you suggest instead?

A. Add a second custom font in eight weights, so headings look richer on every screen.
B. Limit the page to two font weights or a system font, and swap the autoplay video for a compressed still image sized for phones.
C. Keep the video, but move it to the footer so it does not sit in the hero.
D. Load every font weight on every page, so text never flashes while it loads.

**Answer:** B. Fewer weights mean fewer font files to download. A still image sized for the phone replaces a heavy video on the first screen. Both changes reduce what must arrive before the page is ready, which is the source of the slowness.

**Quick check:** A feed of product cards takes about two seconds to load on a phone. The team wants the screen to look useful while it waits. Every card has the same shape. What should the team define?

A. One plain grey rectangle for every screen, so a single file serves all loading states.
B. A skeleton card component that copies the card's shape and size, used wherever product cards load.
C. A centred spinner with no layout, so nothing about the page needs designing.
D. A progress bar that stays on screen after the cards have appeared.

**Answer:** B. A skeleton card that matches the real card keeps the layout stable and shows what is coming. A single generic grey box is a common mistake, and a spinner gives no sense of the content to come. Defining the card skeleton once as a reusable part gives every team the same result.

## Key takeaways

- **Design choices cost time:** Photos, font weights, icon sets, shadows, and animations all add files that must load. Set a budget that caps each group.
- **Feel matters as much as speed:** Skeleton screens, progress indicators, and instant feedback make a wait feel shorter. Define them as reusable patterns in the system.
- **Shared parts multiply impact:** A light core component helps every screen, and a heavy one slows every screen. Check core components when they are built.

Performance is not a job for engineers alone. Designers who choose light assets and write clear limits shape how fast the product feels for every person who uses it.

## Sources

- [Web Design Trends 2027: 12 Shifts Shaping Websites (Lovart blog)](https://www.lovart.ai/blog/web-design-trends-2027)
- [Animated Websites That Are Fast and Rich in Motion (Moburst)](https://digital.moburst.com/animated-websites-that-are-fast-and-rich-in-motion/)
- [Web Font Performance: The Complete Optimization Guide (FontFYI)](https://fontfyi.com/blog/web-font-performance-guide/)
- [Web Performance Budgets: Lessons From 16 Years in Games (exoa.dev)](https://exoa.dev/blog/web-performance-budgets-lessons-from-games)
- [Why Performance-Driven Website Design Converts Better (guljarhosen)](https://guljarhosen.com/blog/why-performance-driven-website-design-converts-better/)
- [High-Performance Web Design: Speed Without Losing Design (StackZeno)](https://stackzeno.com/blog/high-performance-website-design)
- [Set a web performance budget before the visual system (click.blue)](https://www.click.blue/insights/web-performance-budget)
- [Web Font Optimization For Web Designers (Bejamas)](https://bejamas.com/insights/operations/web-font-optimization)
- [The Performance Budget (RIVER)](https://rivergroup.ai/insights/the-performance-budget)
- [Website performance budget: what to agree (Grendesign)](https://grendesign.com.au/website-performance-budget/)
- [Website Performance Budget: A Business Guide (Eckman Design)](https://www.eckmandesign.com/blog/website-performance-budget/)
- [Design Systems Typography Guide (designsystems.com)](https://www.designsystems.com/typography-guides/)
- [SaaS Loading & Skeleton UX: Real Examples & Patterns (saasui.design)](https://www.saasui.design/blog/saas-loading-skeleton-ux-patterns)
- [Skeleton Screens vs Loading Spinners: When to Use Each (onething.design)](https://www.onething.design/post/skeleton-screens-vs-loading-spinners)
- [Loading States, Skeletons, and Optimistic UI (Yashveer Labs)](https://yashveerlabs.vercel.app/blog/loading-states-skeletons-and-optimistic-ui)
- [Skeleton Loading Patterns for Better Perceived Performance (James Ross Jr.)](https://www.jamesrossjr.com/blog/skeleton-loading-patterns)
- [Why Skeleton Screens Beat Spinners (The Frontend Casebook)](https://anmshpndy.com/cases/skeleton-screens-perceived-speed/)
- [Skeleton Screens vs. Spinners: Designing Loading States for Real UX (Mironsoft)](https://www.mironsoft.de/en/blog/skeleton-screens-vs-spinners-designing-loading-states-for-ux)
- [Skeleton Screens vs Loading Spinners: Which Improves Perceived Performance? (The Hangline)](https://www.thehangline.com/skeleton-screens-vs-loading-spinners-which-improves-perceived-performance/)
- [Loading Experience: Skeleton Screens and Progress Indicators (Kırkoç)](https://kirkoc.com/en/blog/yukleme-deneyimi-skeleton-ve-ilerleme-gostergeleri/)
- [Loading States & Skeleton Screens: How to Design Them (CP Cloud Hosting)](https://cpcloudhosting.com/how-to-design-loading-states-and-skeleton-screens/)
