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.
13 min readFree
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.
Key words
- 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.
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?
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?
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)
- Animated Websites That Are Fast and Rich in Motion (Moburst)
- Web Font Performance: The Complete Optimization Guide (FontFYI)
- Web Performance Budgets: Lessons From 16 Years in Games (exoa.dev)
- Why Performance-Driven Website Design Converts Better (guljarhosen)
- High-Performance Web Design: Speed Without Losing Design (StackZeno)
- Set a web performance budget before the visual system (click.blue)
- Web Font Optimization For Web Designers (Bejamas)
- The Performance Budget (RIVER)
- Website performance budget: what to agree (Grendesign)
- Website Performance Budget: A Business Guide (Eckman Design)
- Design Systems Typography Guide (designsystems.com)
- SaaS Loading & Skeleton UX: Real Examples & Patterns (saasui.design)
- Skeleton Screens vs Loading Spinners: When to Use Each (onething.design)
- Loading States, Skeletons, and Optimistic UI (Yashveer Labs)
- Skeleton Loading Patterns for Better Perceived Performance (James Ross Jr.)
- Why Skeleton Screens Beat Spinners (The Frontend Casebook)
- Skeleton Screens vs. Spinners: Designing Loading States for Real UX (Mironsoft)
- Skeleton Screens vs Loading Spinners: Which Improves Perceived Performance? (The Hangline)
- Loading Experience: Skeleton Screens and Progress Indicators (Kırkoç)
- Loading States & Skeleton Screens: How to Design Them (CP Cloud Hosting)
Last updated on 17 November 2026
Related lessons
- System designPerformance Antipatterns: Common Design Mistakes That Slow Systems Under Load
- System designPerformance vs Scalability: Fast for One User Is Not Enough
- Design systemsGuidelines: The Written Rules That Keep Design System Parts Used Well
- System designPerformance Monitoring: Measure Speed Under Real Load to Find Slowdowns Early
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.