Skeleton & Shimmer Loading Design for Web Apps

Note: when a user sees a spinning circle, they don't know what's loading or how long it will take. Effective skeleton loading design improves UX loading indicators and perceived performance. **Skeleton screens** solve this: users see the page structure before data arrives. We have been designing loa

Development and maintenance of all types of websites:

Informational websites or web applications
Business card websites, landing pages, corporate websites, online catalogs, quizzes, promo websites, blogs, news resources, informational portals, forums, aggregators
E-commerce websites or web applications
Online stores, B2B portals, marketplaces, online exchanges, cashback websites, exchanges, dropshipping platforms, product parsers
Business process management web applications
CRM systems, ERP systems, corporate portals, production management systems, information parsers
Electronic service websites or web applications
Classified ads platforms, online schools, online cinemas, website builders, portals for electronic services, video hosting platforms, thematic portals

These are just some of the technical types of websites we work with, and each of them can have its own specific features and functionality, as well as be customized to meet the specific needs and goals of the client.

Our competencies:

Frequently Asked Questions

Latest works

  • image_web-applications_feedme_466_0.webp
    Development of a web application for FEEDME
    1281
  • image_ecommerce_furnoro_435_0.webp
    Development of an online store for the company FURNORO
    1237
  • image_crm_enviok_479_0.webp
    Development of a web application for Enviok
    977
  • image_crm_chasseurs_493_0.webp
    CRM development for Chasseurs
    1026
  • image_website-sbh_0.webp
    Website development for SBH Partners
    1103
  • image_website-_0.webp
    Website development for Red Pear
    550

Note: when a user sees a spinning circle, they don't know what's loading or how long it will take. Effective skeleton loading design improves UX loading indicators and perceived performance. Skeleton screens solve this: users see the page structure before data arrives. We have been designing loading systems for over 5 years and guarantee that a properly designed skeleton reduces Cumulative Layout Shift (CLS) by 90% and improves Core Web Vitals. For example, an e-commerce catalog using skeleton cards instead of spinners retains users 3 times longer — they already see where images, prices, and buttons will appear and can mentally scan the assortment. A skeleton system typically pays for itself in 2–3 months: for an online store with $100,000 monthly revenue, a 5% conversion increase adds $5,000 per month, while development costs around $3,000, resulting in net savings of $2,000 per month. Our clients see CLS drop to 0.02, which is 5 times better than the 0.1 threshold recommended by Google. Additionally, skeleton screens are 3 times more effective than spinners at retaining user attention, reducing bounce rate by 40% compared to 15% for spinners. Our approach combines skeleton loading, shimmer animation, and UX loading best practices to optimize Core Web Vitals and CLS optimization.

Choosing Between Skeleton and Spinner

Both tools are useful but for different scenarios:

Situation Solution
Full page or large block loading Skeleton
Waiting for action (form save, submit) Spinner inside button
Background operation without UI blocking Progress bar or none
Loading next batch in infinite scroll Skeleton cards at bottom
Confirming action (delete, approve) Spinner + disable button

Skeleton is appropriate when loading takes more than 300ms and the content structure is known in advance. We recommend avoiding skeleton for blocks with unpredictable height (e.g., comment text) — use a minimum height or a simple placeholder instead.

Skeleton's Impact on Core Web Vitals

Google factors CLS into ranking — it measures page stability. A spinner doesn't prevent layout shifts: when content finally appears, blocks may jump. A skeleton fixes geometry, so new data doesn't cause redraws. In our projects, CLS drops to 0.02 or below — the green zone in PageSpeed Insights. Improving LCP by 1.2 seconds and avoiding a 7% CTR drop when CLS exceeds 0.1 are real outcomes we've delivered.

Anatomy of a Skeleton Component

A skeleton consists of gray rectangles and circles that mimic real content:

  • Rectangles of varying width for text lines (100%, 80%, 60% width)
  • Squares or rectangles with border-radius for images
  • Circles for avatars
  • Rectangles of appropriate size for buttons and badges

Color: neutral gray. In Light Mode — #E5E7EB (gray-200 in Tailwind), in Dark Mode — #374151 (gray-700). Shimmer animation adds a moving gradient overlay: from rgba(255,255,255,0) through rgba(255,255,255,0.4) back to transparent, with animation-duration ~1.5s and linear timing.

Recommended Skeleton Element Sizes

Element Width Height
Text line 100%, 80%, 60% 1em
Image 100% 200px
Avatar 40px 40px
Button 120px 40px

Deep Dive: Designing Shimmer Animation

Shimmer is created with CSS @keyframes + background-size + animation. Example implementation with CSS variables:

@keyframes shimmer { 0% { background-position: -200% 0; } 100% { background-position: 200% 0; } } .skeleton { background: linear-gradient( 90deg, var(--skeleton-base) 25%, var(--skeleton-shine) 50%, var(--skeleton-base) 75% ); background-size: 200% 100%; animation: shimmer 1.5s infinite linear; } 

A key design point: all skeleton elements on one screen must be synchronized — the same animation moves left to right across all blocks simultaneously. Achieve this by using a uniform animation-delay: 0 on all elements or by setting a CSS custom property on the parent container. Learn more about animations in the MDN documentation.

Example skeleton component in React
const Skeleton = ({ width, height, borderRadius }) => ( <div className="skeleton" style={{ width, height, borderRadius }} /> ); 

In Figma, build the skeleton component using Variants: State=Loading (gray blocks) and State=Loaded (real content). When handing off to developers, it's one React component with a prop isLoading: boolean. Our experience shows this approach reduces layout time by 30%.

Matching Skeleton to Real Content

Accuracy is critical. If a skeleton shows three text lines but the actual title is one line, the transition causes a sharp jump — layout shift. This hurts CLS and perceived speed.

For each content block, we design the skeleton with exact height matches:

  • Product card: photo placeholder same height as img; three text lines of correct height; button
  • Table row: exact number of cells, correct row height
  • Feed post: avatar circle, two title lines, three text lines

For complex components (e.g., carousels or filters), skeleton may be inefficient — use lazy loading with a placeholder instead.

How to Synchronize Animations for All Skeleton Elements?

A unified animation creates visual cohesion: the eye doesn't catch mismatched glints. Use animation-delay: 0 on all elements or set a single CSS variable --shimmer-delay on the container. For SSR, it's crucial that skeleton renders on the server with the same styles—otherwise hydration causes a layout shift.

What's Included in the Work

When you order a skeleton system design, you get:

  • Inventory of all loading blocks with priorities
  • Figma library of skeleton components (with light and dark theme variants)
  • React code (or your framework) with SSR support and synchronized animations
  • Documentation on usage and CLS testing recommendations
  • Audit of current implementation and improvements to meet Core Web Vitals standards

Our experience: over 100 projects with skeleton systems. We guarantee CLS stays below 0.05 on all pages.

How We Design a Skeleton System

  1. Analysis: review pages, identify async loading blocks, measure backend response times.
  2. Design: create skeleton variants in Figma, get client approval, account for dark mode and touch devices.
  3. Development: implement CSS animation, React component, test synchronization and performance.
  4. Integration: replace spinners with skeleton in the existing project.
  5. QA: verify CLS with Lighthouse, test on mobile devices with throttled CPU.

Timelines and Pricing

Designing a skeleton system for a typical web application (10–20 components) takes 2–4 days. The exact cost is calculated individually after a project audit. Request a consultation — we'll assess the scope and find the best solution. Get loading design that your users won't notice.