Ui-Design on Fernando Ruiz

Affordances vs. Signifiers: The Invisible Language of Design

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

An Affordance is the relationship between an object and a person: it is the property of the object that allows an action to be performed (e.g., a handle allows turning). A Signifier is the visual or auditory signal that communicates that capability (e.g., the shape of the handle indicates what to do with it).

Don Norman’s Legacy in UX

The concept of Affordance was originally introduced by James J. Gibson in perceptual psychology, but it was Don Norman who adapted it to design in his seminal book The Design of Everyday Things. For Norman, good design is one that doesn’t need instruction manuals: the user knows what to do just by looking at the object.

Breakpoint vs. Container Queries: Component-Based Design

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Breakpoints (Media Queries) change the design based on the total width of the device screen (Viewport). Container Queries change the design based on the space available to the component within its parent container.

The Paradigm Shift in Product Design

For the last decade, we have designed “screens”: mobile, tablet, and desktop. However, in a modern design system, we design components that live in different places. The same “Product Card” component can appear in a 3-column grid on the home page, or in a single narrow column in a sidebar.

Chunking in UI Flows: Intelligent Fragmentation

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Chunking is the technique of dividing complex information or extensive user flows into smaller, logically grouped “chunks.” This makes it easier for the user’s brain to process, understand, and remember information without feeling overwhelmed.

Why Chunking is vital for Memory?

Our working memory is extremely limited. According to George Miller, we can only hold between 5 and 9 items at once in our mind. If an interface presents us with 20 form fields or a 10-step manual without pauses, our brain becomes saturated, and cognitive load skyrockets.

Cognitive Load Management in UX

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Cognitive Load is the total amount of mental effort a user must invest to complete a task or process information in an interface. Good UX design seeks to minimize unnecessary load so that the user can focus on achieving their goal with as little friction as possible.

Types of Cognitive Load: The Sweller Model

In cognitive psychology, three types of mental load are distinguished. For a UX designer, understanding these concepts is key to creating intuitive interfaces:

Component API Design: Predictability and Flexibility

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Designing a Component API consists of defining a clear entry contract (props) and behavior for elements in a design system, with the goal that they are easy to use, predictable, and maintainable for both designers and developers.

What Makes a Good Component API?

A component is not just a visual piece; it is a unit of functional logic. A well-designed API must clearly answer these three fundamental premises:

Component Prop Organization: Structure and Hierarchy

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Prop Organization consists of structuring and prioritizing a component’s properties so its use is intuitive and predictable. This reduces the cognitive load of designers in Figma and developers in code, facilitating the creation of consistent interfaces.

Why does Prop order matter?

Imagine a complex component (e.g., an Input with a label, icon, error message, and help text). If the configuration properties are disorganized, the design system user (the designer or developer) will waste time looking for how to change the icon color or text size.

Conflict Resolution in Collaboration: UI and UX

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Conflict Resolution occurs when two or more users attempt to perform contradictory actions on the same object at the same time (e.g., one deletes a paragraph while the other is editing it). In collaborative product design, our goal is for the user never to see a “Sync Error” notification if we can avoid it.

The Challenge of Multi-user Applications

In modern applications like Google Docs, Figma, or Notion, real-time collaboration is a basic feature. However, behind the magic lies extremely complex conflict resolution logic. If two people save different versions, who wins? Is anyone’s work lost?

Constraints and Auto Layout Logic in Figma

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Constraints define how elements are positioned and scaled within a static container. Auto Layout is a flexible design system that creates containers that automatically expand or contract based on their content. Together, they form the foundation of any modern responsive design in Figma.

Why are these Tools Vital?

In modern digital product design, we don’t design for a single static screen. We design for an infinite number of devices and contexts. The correct use of Constraints and Auto Layout allows you to:

CRDT Basics for Product Designers

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

CRDTs (Conflict-free Replicated Data Types) are data structures that allow multiple users to make simultaneous, independent changes that, when synchronized, automatically reach the same final state without the need for a central authority or manual conflict resolution. It is the technology that makes modern real-time collaboration possible.

Why the Designer should know what a CRDT is?

Traditionally, in web applications, the server was “the single source of truth.” If you wanted to change something, you asked the server for permission and waited for its “OK” response.

Design System

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

A Design System is a collection of reusable UI components, guided by clear standards (principles, style guides), that enables teams to design and build digital products in a coherent and efficient manner.

What is a Design System?

Imagine you’re building with LEGO. You don’t have to create each brick from scratch every time you build something new. You have a set of standard bricks (2x2, 2x4, etc.) that you can combine to create anything. Plus, you have an instruction manual that tells you how the pieces fit together.

Designing for Perceived Performance: Faster Than Light

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Perceived Performance is the time a user feels it takes for a system to respond, regardless of the actual speed (milliseconds) of the connection or processor. In product design, perception is reality.

Why does Perceived Performance matter?

We can have the best-optimized application in the world, but if the user stares at a blank screen for 2 seconds, they will think the app is slow.

On the contrary, an app that takes the same 2 seconds but shows a Skeleton Screen, a loading bar with a smooth animation, or interesting context messages will be perceived as much faster and more pleasant.

Error Prevention vs. Recovery: A Forgiving Interface

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Error Prevention seeks to design the system so that the user cannot make mistakes. Error Recovery designs the way out when failure has already occurred, helping the user return to the right path without frustration.

The Forgiving Interface Paradigm

Human beings are fallible by nature: we get distracted, we make typing mistakes, or we don’t fully understand instructions. Mature UX design doesn’t blame the user for their errors but assumes they will happen and designs an ecosystem that mitigates or solves them gracefully. This concept is based on two of Jakob Nielsen’s 10 usability heuristics: #5 (Error prevention) and #9 (Help users recognize, diagnose, and recover from errors).

Fitts's Law: Reach and Ergonomics in UI

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Fitts’s Law states that the time required to reach a target depends on the distance to the target and the size of the target itself. In short for UX: Make important actions large and close.

What is Fitts’s Law (and why should you care)?

Paul Fitts, an American psychologist, formulated this law in 1954 to measure human movement. In modern interface design, Fitts’s Law is the foundation of ergonomics: if a button is too small or too far from where the cursor (or thumb) is located, the user will take longer to interact and will make more errors due to lack of precision.

Haptic Feedback Principles: Feeling the Interface

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Haptic Feedback is the physical response (vibration or tactile impact) that a mobile device or wearable emits in response to a user action. It is the third communication channel, along with sight and hearing, which allows the user to “feel” that something has happened without needing to look at the screen.

Why Haptics are Critical for UX?

We live in a world full of visual distractions. Human beings have evolved to feel textures and physical responses when manipulating objects. On a smooth glass screen, we lose that sense.

Hick's Law: Decision and Response Time

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Hick’s Law states that the time it takes for a person to make a decision increases logarithmically as the number and complexity of choices increase. In UX, this translates into a golden rule: Less is faster.

What is Hick’s Law (and why should you care)?

William Edmund Hick and Ray Hyman discovered in the early 1950s that adding extra options not only slows down the user linearly but can actually paralyze them or make them feel overwhelmed (a phenomenon known as “Analysis Paralysis”).

Intrinsic Layout Decisions: Content vs. Boxes

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Intrinsic Layout Decisions are design rules that define how interface elements are positioned and scaled based on the needs of their own content (such as text width or image size) rather than being forced by an external grid (Layout Grid).

Why Intrinsic Layout is the best option for dynamic products?

Historically, we designed websites with 12-column grids. It’s a safe and predictable system, but fragile. If a username is too long, the grid design breaks or text is cut off.

Intrinsic Sizing Behavior in UI

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Intrinsic Sizing is a design behavior where an element’s dimensions (width or height) are determined by its own content (letters, images, icons) rather than being forced by an external container with fixed measurements.

What is Intrinsic Sizing?

Imagine you want to put shirts in a suitcase.

Extrinsic Sizing: The suitcase has a fixed size of 50x40 cm. No matter if you put in 1 shirt or 20, the suitcase measures the same.
Intrinsic Sizing: The suitcase is made of elastic fabric and adjusts exactly to the volume of the shirts you put in. If you put in one shirt, it’s small; if you put in 20, it stretches.

In UI, this means a button doesn’t measure “200px,” but rather Text Width + Lateral Paddings. If the text changes from “OK” to “Unsubscribe,” the button widens automatically.

Latency Budgets in UX: Response Times

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

A Latency Budget is the maximum time allowed (in milliseconds) for a user action to produce a visible response in the interface. It is not a technical metric; it is a design commitment to ensure experience fluidity.

Why the Designer should establish Latency Budgets?

Often, designers create complex flows and heavy interactions without considering the technical cost. If an opening animation of a menu takes 500ms and the server another 1000ms to return data, the user will feel the application is a heavy boat.

Layout Decisions: Grid vs. Intrinsic

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Layout Grids are predefined grids that force elements to follow a rigid structure of specific columns and distances. Intrinsic Layout is an approach where the size and position of elements depend on their content and internal relationship, without relying on an external grid.

The Modern Layout Dilemma

In the web of the early 2010s, everything was based on 12-column grids. Today, thanks to the capabilities of Figma (Auto Layout) and modern browsers (Flexbox/CSS Grid), design is becoming more fluid and less dependent on these fixed structures. The key question is: When should we force the grid and when should we let content rule the space?

Loading States: The Indulgent Wait in UX

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

A Loading State is the visual or audible information shown to the user while the system processes an action (e.g., loading data from a server, uploading a file, or performing a search). Good loading design eliminates the fear of a “frozen system.”

Why Loading States are Critical

The moment a user clicks a button and waits for a response is the time of greatest vulnerability and potential frustration. Without a clear loading state, the user doesn’t know if:

Mental Models of Undo and Redo: Time in the Interface

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Mental Models of Undo and Redo are how the user understands that they can go back or forward in the history of their actions. Correct Undo design reduces user anxiety, allowing them to experiment freely with the interface without fear of making irreversible errors.

The Power of Indulgence (Forgiving UI)

The “Undo” button is the most powerful psychological safety tool in interface design. When a user knows they have a “safety net” under their feet, their cognitive load decreases and their willingness to explore new features increases dramatically. Without Undo, the user becomes conservative and fearful with every click.

Mockups

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

A mockup is a static, high-fidelity representation of a product’s interface. Unlike wireframes, mockups focus on the visual and aesthetic aspects, including colors, typography, images, and other graphic elements to simulate the final product’s appearance.

What are Mockups?

If a wireframe is the blueprint of a house, a mockup is the color model or 3D render that shows how the finished house will look. It’s a static (non-interactive) design that communicates the art direction and visual design of the product.

Offline-First Flows: Designing for Disconnection

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

The Offline-First strategy is a design and development approach that assumes the user will have an intermittent or null internet connection at some point. Instead of treating “Offline” as an error state, it is treated as a fundamental feature of the product. The goal is for the application to always keep working.

The Challenge of Modern Product Applications

Most traditional web apps (like Jira or Gmail) usually break or show a Chrome dinosaur when Wifi is cut. In advanced digital product design, such as Notion, Figma, or Linear, this is no longer acceptable.

Optimistic Updates and Rollback UX

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Optimistic Updates are an interaction design technique where the user interface updates immediately after an action (such as giving a “Like” or sending a message), assuming the server will process the request successfully, without waiting for its actual response. Rollback is the process of reversing that visual change if the request ends up failing.

The Secret of Speed in Modern Apps

Imagine you press the “Like” button on Instagram. If the heart icon didn’t turn red until the server returned an “OK,” the application would feel slow and heavy.

Real-Time Presence Modeling: Collaborative UX

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Presence Modeling is the set of visual and functional indicators that communicate to a user who else is with them in the same digital space (e.g., a Notion page or a Figma file) and exactly what they are doing at that precise moment.

The Magic of Not Being Alone: The Feeling of Presence

A few years ago, applications were lonely: you worked, saved, and closed. Today, product applications are multiplayer. Presence modeling is not just an aesthetic ornament; it is a critical communication tool that prevents users from making mistakes (like editing the same object at the same time) and fosters fluid collaboration.

Responsive Scaling Strategies: Liquid UI

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Responsive Scaling Strategies define how interface elements behave when available space changes. It’s not just about resizing boxes, but deciding which elements grow, which stack, which disappear, and which maintain their original size to ensure usability on any device.

The Challenge of Infinite Screens

Today, we design for a 30mm smartwatch (Apple Watch) and a 49-inch curved monitor. We cannot design a screen for every width. We need a Scaling Strategy that is liquid and resilient.

Safeguards for Destructive Actions: Positive Friction

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Safeguards are intentional friction mechanisms designed to prevent a user from performing irreversible actions (deleting, formatting, closing an account, or removing critical data) accidentally or impulsively. In this case, friction is an ally of the user experience.

The Power of Positive Friction

In standard interface design, we seek to remove any obstacles or friction that slows down the user. However, for destructive actions, friction is humanly necessary. Without it, a single mistaken click could erase years of user work. A good safeguard forces the brain to switch from automatic mode (“System 1”) to analytical and conscious mode (“System 2”).

Skeleton VS Optimistic UI: Loading Strategies

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Skeleton Screens are gray placeholders that mimic the final structure of the page while data is loading. Optimistic UI is a technique that shows the result of an action immediately, assuming the server will respond successfully.

The Art of Waiting: Perceived Performance

In modern product design, speed is not just a matter of real milliseconds (latency), but of how the user feels the system is responding. Both techniques seek to reduce user anxiety during loading, but they are applied at different points in the flow.

Status Awareness in UI

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Status Awareness (State Awareness) is an interface’s ability to clearly and continuously communicate what is happening in the system, at what step of the process the user is, and what the current condition of each component is (e.g., if a button is pressed, if data is loading, or if there is an error).

Why the User Needs Status Awareness?

As human beings, we hate uncertainty. In the physical world, if you flip a switch and the light doesn’t turn on, you know there’s a fault because the switch physically changed position. In the digital world, if a user clicks a button and nothing happens visually in the first few milliseconds, the user will click the button 5 more times, generating server errors and frustration.

The Command Pattern in Product Design

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

The Command Pattern is a software design pattern that encapsulates a user request or action as an independent object. In the world of product design, this allows us to treat each action (delete, move, edit, change color) as an entity that can be stored, undone, redone, and synchronized across multiple users.

Why the Designer Should Know the Command Pattern?

Traditionally, design focused on the final state of screens (the fixed photo). However, modern products (like Figma, Notion, or Google Docs) focus on the actions that lead from one state to another. The Command Pattern is the technical language that makes these transitions possible.

Token Aliasing and Inheritance Strategy

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Token Aliasing consists of defining a token that refers to another token instead of a raw value (like a hexadecimal or pixels). Inheritance is the logical structure that allows design decisions to flow from the most general to the most specific, ensuring consistency and total flexibility in the system.

What is Token Aliasing?

Imagine you want to buy a car in “Sporty Color”.

Raw Value: Red #FF0000
Primitive Token (Global): brand-red -> #FF0000
Semantic Token (Alias): color-background-cta -> brand-red

In this example, color-background-cta is an alias of brand-red. If tomorrow you decide that your brand’s sporty color is Orange, you only have to change the alias reference to brand-orange, and automatically all the call-to-action (CTA) buttons in your product will update. Without aliasing, you would have had to manually search for setiap instance of the color red and change it.

Token Architecture (Global vs. Semantic vs. Component)

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Design token architecture is the logical structure that organizes design decisions (colors, typography, spacing) into layers of abstraction. A well-designed model allows you to change the appearance of an entire product in minutes, ensuring consistency and scalability between design and code.

What is Token Architecture?

Imagine you are building a city. You don’t want to have to paint every brick of every house individually. Instead, you define a “palette of materials” (global tokens), decide that all public buildings will be “institutional color” (semantic tokens), and finally apply that color to the “town hall main door” (component tokens).

Token Parity Across Multiple Platforms

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Token parity ensures that design decisions are translated identically and accurately across different platforms (Web, iOS, Android, Desktop) using a single source system. This eliminates visual inconsistencies and significantly reduces QA effort.

The Challenge of Platform Fragmentation

Each technological ecosystem handles styles (colors, fonts, shadows) uniquely. If a designer chooses a “Primary Blue,” they face:

Web: CSS/SCSS files (rem, px, hex, hsl, rgb).
iOS: Swift/SwiftUI files (Points, UIColor, Asset Catalogs, JSON).
Android: Resource XML or Jetpack Compose (dp, sp, hex ARGB).

Without a parity strategy, the same color may look slightly different or have a different name on each platform, breaking brand consistency and causing confusion among development teams.

Variables vs. Styles in Figma: Strategies and Trade-offs

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Variables are raw and dynamic values (numbers, colors, strings, booleans) that allow for creating themed systems and advanced prototypes. Styles are collections of visual properties (such as gradients, effects, or complex typography) that define an element’s final appearance.

The Dilemma: Variables or Styles?

Figma has evolved toward a much more powerful model with the introduction of Variables, but Styles remain fundamental in many workflows. Understanding the purpose and limitations of each of these elements will help you build a more robust and easy-to-use design library.

Variant Explosion Control (Wrangling Systems)

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Variant Explosion Control is the process of optimizing and simplifying component architecture to avoid an excessive number of manual versions, using tools like Component Properties and Booleans to keep the system lightweight and easy to maintain.

The Problem: The Variant Labyrinth

Before improvements in tools like Figma, creating a simple component (like a button) with 3 sizes, 4 color variants, 2 icon states, and 5 interaction states (default, hover, active, focus, and disabled) required the manual creation of 120 individual variants (3 x 4 x 2 x 5).

Visual Hierarchy VS DOM Hierarchy: Accessibility

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

Visual Hierarchy is the order in which a user sees and processes information on a screen based on size, color, position, and contrast. DOM Hierarchy (Document Object Model) is the order in which HTML code structures and reads that same information. Aligning both is the key to accessibility and SEO.

Why the Designer Should Know the DOM Hierarchy

As designers, we often “draw” elements on the Figma canvas without worrying about their internal order. However, for a Screen Reader or Keyboard user, your design is not an image; it is a sequential list of elements.

Wireframes

Mon, 01 Jan 0001 00:00:00 +0000

info Quick Definition

A wireframe is a low-fidelity visual schematic of an interface, similar to an architect’s blueprint. It focuses on structure, content hierarchy, and functionality, deliberately ignoring visual elements like colors, typography, or images.

What are Wireframes?

Imagine you want to build a house. Before deciding on wall colors or furniture types, you need a blueprint that defines where the rooms, doors, and windows will be. That is exactly what a wireframe is for a digital product.