Chapter 5

Working With Text

Typography is one of the most powerful tools in a designer's arsenal. It communicates hierarchy, establishes tone, guides the eye, and determines whether a design feels professional or amateurish. In Figma, working with text goes far beyond simply typing words on a canvas. It involves making deliberate, informed decisions about typefaces, sizing, spacing, and visual structure. This chapter teaches you how to make those decisions well.

5.1 Adding and Styling Text

Adding text to a Figma canvas begins with the text tool. Press T on your keyboard to activate it. You then have two ways to create a text element.

The first is a click. Clicking once on the canvas creates a text element that expands horizontally as you type. It has no fixed width and will continue growing on a single line until you press Enter or click away. This is called auto-width text, and it is useful for short labels, headings, and single-line elements where you want the container to size itself to the content.

The second is a click and drag. Clicking and dragging creates a text box with a fixed width. As you type, the text wraps automatically when it reaches the right edge of the box. The height of the text box grows to accommodate the content. This is called auto-height text, and it is appropriate for paragraphs, descriptions, and any multi-line text content.

Once you have a text element on the canvas and it is selected, the right sidebar updates to show the full typography panel. Here you will find every property you need to style your text.

Font Family

At the top of the typography section is the font family selector. Click on it and type the name of any font to search for it. Figma has access to the entire Google Fonts library as well as any fonts installed on your local machine. The font family is the most impactful typographic choice you will make for any piece of text.

Font Weight

Directly beneath the font family is the font weight selector. Most typefaces offer multiple weights: Thin, Light, Regular, Medium, Semi Bold, Bold, Extra Bold, and Black. The exact options vary by typeface. Font weight is one of the primary tools for creating visual hierarchy.

Font Size

Font size is measured in pixels in Figma. The size field is next to the font weight selector in the right sidebar. You can type a specific value or use the arrow keys to nudge the size up or down by one pixel at a time.

Line Height

Line height controls the vertical space between lines of text within a paragraph. Figma allows you to set line height as an absolute pixel value or as a percentage of the font size. A line height of 150% is a commonly used default for body text, providing comfortable reading spacing. Tighter line heights (100 to 120%) are often used for headings.

Letter Spacing

Letter spacing (also called tracking) adjusts the horizontal space between all characters in a text element. It is measured in pixels or as a percentage of the font size. Negative letter spacing pulls characters closer together and is often used with large headings to create a more refined, compressed look. Positive letter spacing is often used with small uppercase labels to improve legibility.

Text Decoration and Transform

Below the main sizing controls, Figma offers text decoration options including underline and strikethrough, as well as text transform options: uppercase, lowercase, and title case. These are applied non-destructively, meaning the original text is preserved even when it is displayed in all caps.

  

5.2 Font Pairing Basics

A font pairing is the deliberate combination of two or more typefaces used together in a design. Good font pairing creates visual harmony while establishing clear hierarchy. Poor font pairing creates visual noise and makes a design feel unprofessional.

The foundational principle of font pairing is contrast with compatibility. The two typefaces should be noticeably different from each other — different enough that the distinction is clear — but share enough underlying characteristics that they feel like they belong in the same design.

Serif and Sans-Serif Pairing

The most reliable and widely used pairing strategy is combining a serif typeface with a sans-serif typeface. Serif fonts have small decorative strokes (serifs) at the ends of their letterforms. They tend to feel classical, authoritative, and editorial. Sans-serif fonts lack these strokes and tend to feel modern, clean, and accessible. Pairing a serif for headings with a sans-serif for body text (or vice versa) creates an immediate and reliable visual contrast.

Reliable examples of this pairing include Playfair Display (serif) with Inter (sans-serif), Merriweather (serif) with Source Sans Pro (sans-serif), and Lora (serif) with Nunito (sans-serif).

Sans-Serif and Sans-Serif Pairing

Pairing two sans-serif fonts is more challenging because the fonts must have enough contrast in weight, width, or personality to read as distinct. A common approach is to use a geometric or display sans-serif for headings and a highly legible neutral sans-serif for body text.

Examples: Space Grotesk with Inter, Outfit with Roboto, Clash Display with DM Sans.

What to Avoid

Avoid pairing fonts that are too similar. Two fonts from the same stylistic category with similar proportions will not create meaningful contrast and will look like a mistake rather than a choice. Also avoid using more than two typefaces in a single design. Using three or more fonts almost always creates visual confusion rather than richness.

  

5.3 Text Alignment and Spacing

Text alignment and spacing are not decorative choices. They are functional decisions that directly affect how easily a reader can consume your content.

Alignment

Figma provides four text alignment options: left, center, right, and justified. Left alignment is the default and the most legible for most languages, particularly for body text and long paragraphs. The eye has a consistent left edge to return to at the start of each new line, which reduces cognitive effort.

Center alignment works well for headings, short labels, pull quotes, and call-to-action text where you want to create a formal, balanced composition. It becomes difficult to read when applied to paragraphs longer than two or three lines.

Right alignment is used sparingly in UI design, most commonly for numbers in data tables, timestamps in chat interfaces, and certain localization contexts.

Justified alignment forces all lines of text to span the full width of the text box by adjusting spacing between words. It can look clean in print design but tends to create awkward gaps in digital interfaces, particularly on narrow screen widths. Use it with caution.

Paragraph Spacing

In Figma's advanced text options (accessed by clicking the three-dot icon in the typography section of the right sidebar), you will find paragraph spacing controls. Paragraph spacing adds vertical space between paragraphs, distinct from line height. Good paragraph spacing helps readers identify where one thought ends and another begins without needing a blank line as a separator.

Optical Alignment

One advanced concept worth introducing early is optical alignment. When large text is placed against an edge, the visual impression of alignment can be slightly off even when the technical position is correct. This happens because the white space within letters (particularly letters like "T," "A," and "W") creates an optical illusion of inset. Professional designers often nudge text slightly beyond the technical boundary to achieve true visual alignment. Figma's nudge tool and precise X/Y input fields make this kind of fine adjustment easy.

5.4 Creating Text Hierarchies (Headings, Body, Captions)

Text hierarchy is the visual system that tells a reader where to look first, second, and third. Without hierarchy, all text appears equally important, which paradoxically makes all of it harder to read because the eye has no guidance.

A well-constructed text hierarchy uses a combination of size, weight, color, and spacing to create a clear visual ranking of information.

H1 — Primary Heading

The H1 is the largest and most prominent text element on a screen or page. It introduces the primary subject of the content. In mobile design, H1 headings typically range from 28 to 40 pixels. In desktop web design, they often range from 48 to 96 pixels. H1s are almost always Bold or Extra Bold weight. There should only be one H1 on any given screen.

H2 — Secondary Heading

The H2 introduces a major section within the content. It is noticeably smaller than the H1 but still clearly larger than the body text. Typically 22 to 32 pixels in mobile contexts, 32 to 48 in desktop. H2s are often Semi Bold or Bold.

H3 — Tertiary Heading

The H3 introduces sub-sections and supporting structure. It is a step below H2 in visual prominence. Typically 18 to 24 pixels. H3s are often Medium or Semi Bold weight and sometimes use a slightly different color from H1 and H2 to mark the distinction.

Body Text

Body text is the primary reading text. It must prioritize legibility above all else. The standard size range for body text in digital design is 14 to 18 pixels for mobile and 16 to 20 for desktop. Regular weight is almost always appropriate. Line height should be generous: 150% to 160% of the font size. Text color for body content is rarely pure black. A dark grey such as #374151 or #1F2937 is more comfortable to read at length.

Captions and Labels

Captions are the smallest text elements in a hierarchy. They appear beneath images, inside form fields, in footnotes, and as metadata labels. Typically 11 to 13 pixels. They are often Regular or Light weight and use a lighter color than body text to further reduce their visual prominence.

5.5 Google Fonts Inside Figma

One of Figma's most useful built-in capabilities is its direct integration with Google Fonts, the world's largest library of free, open-source typefaces. Without installing anything or leaving the application, you have access to over a thousand typefaces covering hundreds of languages and every stylistic category.

Accessing Google Fonts in Figma is effortless. When you have a text element selected and click the font family field in the right sidebar, simply start typing any font name. Figma searches Google Fonts in real time as you type. Select any result and the font is immediately applied to your text, downloaded automatically in the background.

Finding the Right Font

If you are not searching for a specific font by name but want to explore options, there are two useful approaches. The first is to visit fonts.google.com in a separate browser tab where you can filter fonts by category (Serif, Sans Serif, Display, Monospace, Handwriting), by language, and by various style characteristics. Note the names of fonts you like, then apply them in Figma.

The second approach is to use the Figma plugin Fontbase or similar font exploration plugins, which allow you to preview multiple fonts applied to your actual design text without manually typing each name.

Recommended Google Fonts for UI Design

Not all Google Fonts are well-suited for interface design. The following are consistently reliable choices that render crisply on screens and cover a range of aesthetic directions.

For clean, modern interfaces: Inter, DM Sans, Outfit, Nunito Sans. For editorial and content-heavy designs: Merriweather, Lora, Source Serif Pro. For display headings with personality: Space Grotesk, Syne, Clash Display (via plugin). For monospace and code contexts: JetBrains Mono, Fira Code, Source Code Pro.

Variable Fonts

An increasingly important category within Google Fonts is variable fonts. A variable font is a single font file that contains a continuous range of weights, widths, and other design axes, rather than separate files for each weight. In Figma, variable fonts appear with a slider control in the font weight field, allowing you to set the weight to any value rather than choosing from discrete steps. This gives you extraordinary typographic precision and is worth seeking out when fine control over weight matters.

Chapter 6

Color and Fills

Color is not decoration. In interface design, color communicates meaning, establishes brand identity, guides user behavior, creates hierarchy, and affects accessibility. Working with color thoughtfully in Figma is one of the marks that separates a beginner from a developing designer. This chapter takes you through every color tool Figma offers and shows you how to use them with intention.

6.1 Solid Colors, Gradients, and Image Fills

Every shape and frame in Figma can receive a fill, which is the visual content that occupies its interior. Figma supports four types of fill: solid color, gradient, image, and none.

Solid Color

A solid color fill is a single, uniform color applied to an element. It is the most common fill type and the foundation of most UI design. You assign a solid color by clicking the fill color swatch in the right sidebar, which opens the color picker. We will cover the color picker in detail in section 6.2.

Linear Gradient

A linear gradient transitions smoothly between two or more colors along a straight line. You can control the angle of the gradient, the position of each color stop, and the color and opacity at each stop. Linear gradients are used for backgrounds, button states, decorative elements, and sometimes for text fills in display headings.

To create a linear gradient, click the fill type dropdown in the right sidebar (the square icon to the left of the color swatch) and select Linear. Two handles will appear on the element: one for the start color and one for the end color. Dragging these handles changes the gradient's angle and length. Clicking anywhere along the gradient line adds a new color stop.

Radial Gradient

A radial gradient transitions from a center point outward in a circular pattern. The center handle controls where the gradient originates, and the outer handle controls the radius. Radial gradients create a sense of light emanating from a source and are useful for glow effects, spotlight backgrounds, and circular UI elements.

Angular Gradient

An angular gradient sweeps the color transition around a central point in a circular rotation, like the sweep of a clock hand. It is less commonly used in UI design but appears in data visualization, loading indicators, and decorative circular graphics.

Diamond Gradient

A diamond gradient radiates from a center point in a diamond pattern rather than a circular one. It is the most specialized of the gradient types and is used primarily for ornamental and decorative purposes.

Image Fill

An image fill places an image inside any shape or frame. Rather than the image existing as a separate layer on top of a shape, the shape itself becomes the image container. This is powerful for creating masked image layouts where content is contained within non-rectangular shapes.

To apply an image fill, click the fill type dropdown and select Image, then click the Choose Image button to upload a file from your computer, paste an image from the clipboard, or drag and drop an image from your file system directly onto the selected shape.

Image fills offer four fitting modes: Fill (the image scales to cover the entire shape, cropping if necessary), Fit (the image scales to fit within the shape, potentially leaving empty space), Crop (you can manually reposition and scale the image within the shape), and Tile (the image repeats to fill the shape).

6.2 Using the Color Picker

The Figma color picker is a versatile tool for selecting, adjusting, and managing colors. Opening it reveals several different ways to specify a color, each with its own advantages depending on the situation.

The Gradient Spectrum

At the top of the color picker is the large gradient spectrum field. This is the primary visual interface for color selection. Horizontal position controls saturation (left is fully desaturated, right is fully saturated). Vertical position controls lightness (top is white, bottom is black). You drag the circular handle to select a hue and saturation combination, then fine-tune with the sliders below.

The Hue Slider

Beneath the spectrum field is a horizontal rainbow slider that lets you select the base hue (the pure color before adjustments for lightness or saturation). Dragging this slider cycles through the full range of visible colors.

The Opacity Slider

Below the hue slider is the opacity (alpha) slider, which controls the transparency of the color. Fully opaque is at the right end. As you drag toward the left, the color becomes increasingly transparent. Setting a color to partial opacity is one of the ways to create softer, blended visual effects.

The Hex Input Field

Below the sliders is a hex code input field. The hex code is a six-character alphanumeric string that precisely identifies a color. Hex codes are the standard language of color in web and digital design: when a brand specifies its exact colors, it will typically provide hex codes. You can type or paste any hex code directly into this field to jump to that exact color instantly. This is the fastest way to apply a specific brand color.

RGB and HSL Modes

Clicking the dropdown to the left of the hex input field lets you switch the color input mode. RGB mode displays the red, green, and blue channel values (each from 0 to 255) that compose the color. HSL mode displays hue (0 to 360 degrees), saturation (0 to 100%), and lightness (0 to 100%). HSL is often more intuitive for designers because it maps more closely to how we naturally think about color: you choose a color, then decide how saturated and how light you want it.

The Eyedropper

The eyedropper icon in the color picker lets you sample any color visible on your screen, whether it is inside your Figma canvas or in another application entirely. Click the eyedropper, then click on any color anywhere on your screen, and that color is immediately applied. This is invaluable when you need to match colors from a brand's existing website, a reference image, or any external source.

6.3 Creating and Saving a Color Palette

A color palette is a curated set of colors that work together harmoniously and consistently throughout a design. Every professional design project should have a defined color palette before detailed visual design begins. In Figma, you can create and save color palettes as color styles, which makes them reusable across your entire project.

Defining Your Palette Structure

A practical UI color palette is not just a collection of pretty colors. It has a deliberate structure that serves functional purposes. A well-organized palette typically includes the following categories.

A Primary color is your brand's signature color. It appears on the most important interactive elements: buttons, links, and active states. Choose a color that is distinctive, accessible on light and dark backgrounds, and appropriate for the brand's personality.

Secondary colors complement the primary and appear on supporting elements. They create visual interest without competing with the primary color's dominance.

Neutral colors form the backbone of most interfaces. They are the whites, off-whites, light greys, medium greys, dark greys, and near-blacks that compose backgrounds, borders, and secondary text. A professional palette typically includes six to eight neutral shades that step evenly from very light to very dark.

Semantic colors carry universal meaning: green for success and confirmation, red for errors and destructive actions, yellow or amber for warnings, and blue for informational messages. These colors should be consistent throughout an interface so that users learn to associate them with specific types of feedback.

Saving Colors as Styles in Figma

To save a color as a style in Figma, apply the color to any shape, then click the plus icon next to the Fills section in the right sidebar. A dialog appears asking you to name the style. Use a clear, systematic naming convention: for example, Primary/500, Neutral/100, Neutral/900, Semantic/Success, Semantic/Error.

Once saved, color styles appear in the styles panel (the four-dot grid icon in the right sidebar) and can be applied to any element with a single click. Changing a color style updates every element in the file that uses it simultaneously, which is one of the most powerful time-saving features in Figma.

  

6.4 Opacity and Blend Modes

Beyond fill color, Figma gives you two additional tools for controlling how an element interacts visually with the layers beneath it: opacity and blend modes.

Opacity

Opacity controls the overall transparency of an entire layer, including all of its contents, fills, strokes, and effects. It is distinct from the opacity of the fill color: fill opacity affects only the fill, while layer opacity affects the entire element.

You set layer opacity in the right sidebar using the percentage field next to the blend mode dropdown, or by selecting a layer and pressing a number key. Pressing 5 sets opacity to 50%. Pressing 0 sets it to 100%. Pressing 55 sets it to 55%.

Opacity is used extensively in design for overlay effects, ghost states (showing inactive elements at reduced opacity), layered image treatments, and creating subtle depth through transparent shadows.

Blend Modes

Blend modes determine how a layer's colors interact mathematically with the colors of everything beneath it. By default, every layer in Figma uses the Normal blend mode, which simply displays the layer's colors as-is, with transparency controlled by opacity.

The other blend modes fall into several categories based on their effect. The darkening modes (Multiply, Darken, Color Burn) make the result darker than either the layer or what is beneath it. Multiply is particularly useful: it works like stacking transparent colored films. A black layer in Multiply mode becomes completely transparent. This makes Multiply ideal for applying color overlays to images without losing the image detail beneath.

The lightening modes (Screen, Lighten, Color Dodge) make the result lighter. Screen is the opposite of Multiply and is excellent for light-based effects like glows and lens flares.

The contrast modes (Overlay, Soft Light, Hard Light) increase contrast between light and dark areas while preserving the texture of both layers. Overlay is a common choice for adding a subtle color tint to an image without washing it out.

The color modes (Hue, Saturation, Color, Luminosity) apply specific color properties of one layer to the color properties of another. The Color blend mode, for example, applies the hue and saturation of the top layer while preserving the luminosity (brightness) of the layer beneath. This is useful for colorizing grayscale images.

  

6.5 Building a Style Guide

A style guide is a reference document that captures all of the visual rules for a design project in one place. It documents the color palette, typography choices, spacing values, component styles, and usage guidelines that ensure consistency across every screen. In Figma, building a style guide is both a practical exercise and a professional skill that will serve you in every project you take on.

Why Style Guides Matter

Without a style guide, consistency in a design depends entirely on memory and manual effort. Every time you add a button, you have to remember the exact corner radius, fill color, font size, and padding from the last button you designed. Every time you add a heading, you have to manually check the font weight and size from another screen. This approach does not scale, and it leads to the kind of subtle inconsistencies that make designs look unpolished.

A style guide moves this knowledge from your memory into a shared, referenceable document. It is particularly valuable in team environments where multiple designers need to produce work that looks cohesive, but it is equally valuable for solo designers who want to maintain consistency across a complex project over time.

What to Include in a Figma Style Guide

A complete style guide for a digital product typically includes the following sections: the color palette with all saved color styles and their intended use, the typography system with all text styles including sizes, weights, and line heights, the spacing and grid system documenting the base unit, grid settings, and common spacing values, the component library preview showing all base components in their various states, the iconography section showing the icon set in use and any usage guidelines, and the imagery style demonstrating the kind of photography, illustration, or graphic style appropriate for the brand.

Building It in Figma

The most practical approach is to dedicate a specific page within your project file to the style guide. Create frames for each section and design them as clearly as possible, treating the style guide itself as a deliverable that another designer or developer could read and understand without any additional explanation from you.

As you build out your Figma skills throughout this article, you will add to this style guide progressively. By the time you reach the real-world projects in Part Six, you will have a complete, professional style guide that documents the design system you have built.

  

Designer's Note

Your style guide is a living document, not a one-time artifact. Every time you make a deliberate design decision — a new component, a new color style, a new spacing rule — update your style guide to reflect it. The discipline of maintaining this document as you work will make you a significantly more organized and professional designer.

Chapter 7

Images and Icons

Images and icons are the visual vocabulary of interface design. They communicate meaning faster than words, guide user attention, establish emotional tone, and make interfaces feel alive rather than purely typographic. Knowing how to import, manage, mask, and source these assets inside Figma is an essential skill that you will use in virtually every project you ever design.

7.1 Importing Images Into Your Design

Figma supports importing images in several formats including PNG, JPG, GIF, TIFF, WEBP, and SVG. There are multiple ways to get an image onto your canvas, and knowing all of them gives you flexibility depending on the situation.

Drag and Drop

The simplest method is to drag an image file directly from your computer's file explorer or desktop onto the Figma canvas. Figma places the image as a new layer at the location where you drop it. The image dimensions match the original file's pixel dimensions by default.

Place Image via the Toolbar

In the toolbar, clicking the shapes dropdown and selecting Place Image (or pressing Shift + Command + K on Mac, Shift + Control + K on Windows) opens a file browser. You can select one or multiple images. If you select multiple images, Figma loads them all into your cursor sequentially, and each click on the canvas places the next image. This method is particularly efficient when you need to populate multiple image containers at once.

Paste from Clipboard

If you have copied an image to your clipboard from a browser, another application, or a screenshot tool, you can paste it directly onto the Figma canvas with Command + V (or Control + V). This is the fastest method for working with screenshots, web images, and photos you have found during research.

Importing Into an Existing Shape

One of Figma's most useful image behaviors is that you can drag an image directly onto an existing shape to fill that shape with the image. Select a rectangle, ellipse, or any other shape, then drag an image file onto it. The shape immediately uses the image as its fill, and the image is automatically cropped and scaled to fit the shape's dimensions. This technique is foundational for building card layouts, profile picture containers, and hero image sections.

Managing Image Resolution

Figma works with images at their original resolution and scales them within the interface. When exporting designs for development, you can specify export multipliers (1x, 2x, 3x) to generate versions of your assets at the appropriate resolution for different screen densities. For design work inside Figma, always use the highest resolution version of any image you have available. Low-resolution images look pixelated when zoomed in and are difficult to work with at large sizes.

  

7.2 Image Cropping and Masking

Placing an image in your design is only the first step. Controlling precisely which part of the image is visible, and in what shape, is where Figma's cropping and masking tools become essential.

Cropping an Image

When an image is placed as a fill inside a shape, you can enter crop mode by double-clicking the image (or clicking the Crop button that appears in the right sidebar when an image fill is selected). In crop mode, the image appears with a dark overlay and a set of handles around its edges. Dragging these handles moves the crop boundary, determining which portion of the image is visible. Clicking and dragging inside the image (not on the handles) pans the image within the fixed frame, letting you reposition which part of the photo is centered.

This is the method for all basic image repositioning. If you have a landscape photo in a square frame and the subject is off-center, double-click the image and drag to reposition the subject to the center of the frame.

Masks: Going Beyond Rectangles

Cropping confines an image to the bounds of the shape that contains it. Masking is a more powerful technique that allows you to reveal an image through the shape of any vector form, regardless of how complex or irregular that shape is.

Here is how masking works in Figma. First, place the image on the canvas as a standalone element (not as a fill). Second, draw the shape you want to use as the mask on top of the image. This mask shape defines the visible area of the image beneath it. Third, select both the image and the mask shape together. Fourth, right-click and choose Use as Mask (or press Control + Alt + M on Windows, Command + Option + M on Mac).

The image is now only visible through the shape of the mask. Everything outside the mask shape is hidden. The mask shape itself becomes invisible (it becomes a purely structural element) and the image shows through it.

Masks can use any shape: circles for round profile pictures, custom polygon shapes for editorial layouts, text shapes for typographic image effects, or even complex illustrated paths for creative compositions.

Clipping vs. Masking

A subtle but important distinction: when you place an image inside a frame, the frame clips the image (hides the overflow) automatically based on the frame's boundaries. This is clipping, not masking. Masking uses a shape layer explicitly designated as the mask. Both achieve similar visual results for rectangular areas, but masking is the only technique that allows non-rectangular image reveals.

  

7.3 Using Figma Community Icons

Icons are a critical component of nearly every digital interface. They provide visual shorthand for actions, categories, and concepts that would otherwise require words. Figma's Community is one of the richest sources of free, high-quality icons available to any designer.

Accessing the Figma Community

The Figma Community is accessible from the home screen by clicking the Community tab in the left sidebar. From within an open file, you can access community resources through the Resources panel (the grid icon in the toolbar), which has a Community tab showing plugins and files.

The Community contains thousands of icon sets contributed by designers worldwide, ranging from minimal single-weight sets to comprehensive multi-style libraries with thousands of individual glyphs. Many of these are completely free to use in both personal and commercial projects.

Most Popular Free Icon Libraries in Figma

Several icon libraries stand out for their quality, comprehensiveness, and community adoption.

Material Symbols is Google's official icon library, containing over three thousand icons in outlined, filled, and rounded styles. It is systematic, highly legible at small sizes, and extremely well-suited to Android and Material Design projects.

Heroicons is a set of over two hundred clean, consistent icons in both outline and solid variants created by the team behind Tailwind CSS. They are particularly popular for web application design.

Phosphor Icons offers over seven thousand icons across six weights (Thin, Light, Regular, Bold, Fill, and Duotone), making it one of the most flexible icon systems available.

Feather Icons is a minimal set of around three hundred clean outline icons that have become a staple in clean, modern web design.

Lucide is a community fork of Feather with expanded coverage and active ongoing development.

Using Icons From Community Files

After finding an icon set you like, click Duplicate to save a copy to your drafts, or open the file and copy individual icons directly. Icons from well-structured community files are typically organized as components, which means you can use them as instances in your design and swap between them easily.

A more efficient approach is to install icon libraries as shared libraries, which makes their components available directly in your design file's assets panel without needing to copy them manually. This is covered in depth in Chapter 9.

7.4 Working With SVG Files

SVG stands for Scalable Vector Graphics. It is a file format that stores images as mathematical instructions (paths, curves, and coordinates) rather than pixels. This means SVG files can be scaled to any size, from a 16x16 pixel favicon to a billboard, without any loss of quality. For interface design, SVG is the standard format for icons, illustrations, logos, and any graphic element that needs to appear sharp at multiple sizes or on high-density screens.

Importing SVG Files Into Figma

Importing an SVG into Figma is as simple as dragging the file from your computer onto the canvas. What makes SVG different from raster formats like PNG and JPG is what happens after the import. Rather than becoming an opaque image fill, an imported SVG becomes a fully editable vector object inside Figma. Its paths, curves, and shapes are all accessible and modifiable, just as if you had drawn them yourself in Figma.

This means you can change the fill color of an imported icon SVG, adjust its paths, scale it to any size without quality loss, and even animate it in prototypes.

Exporting SVG Files From Figma

Any vector shape, icon, or illustration created in Figma can be exported as an SVG. Select the element, scroll to the Export section at the bottom of the right sidebar, click the plus icon to add an export setting, and choose SVG from the format dropdown. Click Export to download the file.

SVG exports from Figma are clean and well-structured. However, for complex illustrations with many layers, the resulting SVG code can be verbose. Tools like SVGO or the Figma plugin SVG Export can be used to optimize the file size of exported SVGs.

Editing Imported SVG Icons

One of the most practical uses of SVG editing in Figma is customizing icons from external libraries. If you find an icon that is almost right but not quite, import it as an SVG, double-click to enter vector editing mode, and modify the anchor points and paths to adjust the design. This gives you far more flexibility than working with rasterized icons.

You can also use SVG icons as a base for creating design assets. Import a simple outline icon, expand the strokes to convert them to filled shapes, then use boolean operations to combine, subtract, or modify the forms into a custom icon variant.

Colors in SVG

One important technical detail when working with SVG icons: some SVG files define their colors inline in the file's code using specific hex values. When you import such an SVG into Figma, the fill colors may appear locked or may not respond to the fill color selector in the right sidebar in the expected way. To fix this, select the icon, then use Edit > Select All With > Same Fill Color to select all paths, and then change the fill color. Alternatively, right-clicking and choosing Flatten will merge all paths into a single layer whose fill you can change directly.

7.5 Plugins for Finding Free Assets

Figma's plugin ecosystem is one of its most powerful features for asset sourcing. Rather than leaving Figma to find images, icons, and illustrations, you can access enormous libraries of free assets directly within your design workflow through plugins.

Accessing Plugins

Plugins are accessed through the Resources panel (the grid icon in the toolbar). Click the Plugins tab and search by name, or browse categories. To install a plugin, click the three-dot menu next to it and select Save. Once saved, plugins appear in your Plugins menu and can be run directly from within any open file.

Unsplash

Unsplash is the single most useful asset plugin for beginners. It provides access to over three million high-resolution, royalty-free photographs that can be inserted directly into any selected frame or shape with a single click. You can search by keyword, browse categories, and populate image placeholders instantly without leaving Figma. For prototypes, mockups, and any design work that requires photography, Unsplash eliminates the need to find and import images manually.

Iconify

Iconify aggregates over two hundred thousand icons from more than one hundred and fifty open-source icon libraries into a single searchable interface. Rather than choosing between icon sets and installing them separately, Iconify lets you search across all of them simultaneously and insert any icon directly into your canvas as an editable SVG. This is the fastest way to find a specific icon when you know what you need but are not committed to a particular library's style.

Illustrations by Storyset / Blush / Humaaans

These three plugins provide access to free customizable vector illustrations. Storyset and Blush offer large libraries of scene and character illustrations that can be customized to match your color palette. Humaaans specializes in modular human figure illustrations where you can mix and match body parts, clothing, and poses to create unique characters. All three are invaluable for onboarding screens, empty state illustrations, and hero sections.

Photos by Pexels

Similar to Unsplash, the Pexels plugin provides access to a large library of free stock photography directly within Figma. Pexels tends to have a slightly different photographic aesthetic from Unsplash and is worth having alongside it to broaden your options.

Content Reel

Content Reel is a Figma plugin that populates your designs with realistic placeholder content: names, email addresses, phone numbers, addresses, avatar photographs, and more. Rather than filling text layers with "Lorem ipsum" and placeholder initials, Content Reel lets you populate a design with realistic data in seconds. This makes your mockups far more convincing and helps you spot layout problems that only emerge with realistic content lengths.

PART THREE

DESIGN THINKING IN FIGMA

Chapter 8

Layout and Spacing

Good design is not just about beautiful colors and typography. It is about structure. The way elements are arranged on a screen, the distances between them, the invisible grids that govern their placement — these are the foundations of a design that feels organized, intentional, and trustworthy. This chapter introduces the layout and spacing systems that professional designers use daily, and shows you how Figma is built to support them at every level.

8.1 The 8-Point Grid System

The 8-point grid system is one of the most widely adopted layout conventions in digital product design. Its premise is elegantly simple: all spacing and sizing values in a design should be multiples of eight.

This means elements are sized and positioned at values like 8, 16, 24, 32, 40, 48, 56, 64, 72, and 80 pixels. Padding inside components uses these values. Gaps between components use these values. Font sizes, line heights, icon sizes, border radii — wherever possible, these values snap to the 8-point scale.

Why Eight?

Eight is divisible by many of the numbers that matter in design: 1, 2, 4, and 8. This means a base unit of 8 can be halved down to 4 or 2 for fine details (like a 2-pixel border or 4-pixel inner padding on a compact element) without losing mathematical consistency. Additionally, most modern screen densities, including the most common iOS and Android display scales, use pixel ratios that divide evenly into 8, which means 8-point values render cleanly on virtually all screens without subpixel rounding artifacts.

The 4-Point Variation

Many designers use a 4-point grid as their base unit instead of 8. This provides more granularity for detailed component work while still maintaining systematic spacing. In practice, a 4-point system and an 8-point system are compatible: the 8-point system simply uses even multiples of 4. You will often see both described interchangeably, and the underlying philosophy is identical.

Using the 8-Point Grid in Practice

Applying the 8-point grid does not require measuring every element manually. Once you internalize the scale, most design decisions happen naturally within it. The practical habit is to set Figma's nudge value to 8. By default, pressing an arrow key moves a selected element by 1 pixel, and pressing Shift + arrow moves it by 10. You can change the Shift nudge value to 8 in Figma's preferences (Command + comma on Mac) under the Nudge Amount section. Setting this to 8 means that Shift + arrow key always moves elements in grid-consistent increments.

  

8.2 Using Layout Grids in Figma

A layout grid is a system of columns, rows, or uniform squares overlaid on a frame to guide the placement of design elements. Layout grids are one of the most important tools for creating designs that feel structured and organized, and Figma makes adding and customizing them straightforward.

Adding a Layout Grid

Select any frame on your canvas. In the right sidebar, scroll to the Layout Grid section and click the plus icon. A default grid appears immediately as a red overlay on your frame. This default is a square grid with 10-pixel cells, but you will almost always want to customize it.

Column Grids

The most common layout grid for screen design is a column grid. Click the grid type selector (the small icon to the left of the grid color swatch) and choose Columns. Several properties appear that you can configure.

Count is the number of columns. The most common values are 12 columns for desktop layouts, 4 columns for mobile layouts, and 8 columns for tablet layouts. A 12-column desktop grid is particularly flexible because 12 is divisible by 2, 3, 4, and 6, allowing elements to span varying numbers of columns while maintaining alignment.

Margin is the space between the edge of the frame and the outermost columns. This defines the "breathing room" between your content and the edge of the screen. Common values for mobile are 16 or 24 pixels. For desktop, margins are often 80 to 120 pixels.

Gutter is the space between adjacent columns. It defines the minimum distance between blocks of content in adjacent columns. Common gutter values are 16 to 32 pixels.

Row Grids

Row grids divide a frame into horizontal bands, each of a specified height. They are less commonly used than column grids but are useful for designing layouts where vertical rhythm is critical, such as email designs or document layouts.

Baseline Grids

A baseline grid overlays the frame with uniform square cells, creating a reference for both horizontal and vertical alignment simultaneously. This is useful for detailed component work where you want to ensure elements align to the same underlying structure.

Multiple Grids

Figma allows you to add multiple layout grids to a single frame. A common professional practice is to add both a column grid and a baseline grid: the column grid governs horizontal layout structure and the baseline grid ensures vertical alignment consistency.

8.3 Auto Layout — Designing Like a Developer

Auto Layout is arguably the most transformative feature in Figma for designers who work on real products. It allows you to create frames whose contents automatically reflow and resize based on rules you define — much like how HTML elements behave in a web browser with CSS flexbox applied.

Before Auto Layout, resizing a button to accommodate longer text meant manually adjusting the frame width and repositioning the text layer. With Auto Layout, the button frame grows and shrinks automatically as the text content changes. Before Auto Layout, adding a new item to a list meant manually moving every item below it downward to make room. With Auto Layout, adding a new item causes the container to expand automatically, preserving all the defined spacing.

Creating an Auto Layout Frame

Select any frame (or select a group of elements) and press Shift + A. Figma immediately converts it into an Auto Layout frame. A set of new controls appears in the right sidebar under the Auto Layout section.

Direction

The Direction property determines whether Auto Layout arranges its contents horizontally (side by side, like a row of buttons in a toolbar) or vertically (stacked, like a list of items or a card's content). Click the horizontal or vertical arrows in the Auto Layout controls to switch between them.

Spacing Between Items

This is the gap between child elements within the Auto Layout frame. Type a value directly into the spacing field or use the arrow keys to nudge it. This gap is maintained automatically: if you add or remove elements, or if any element changes size, the spacing between all elements remains exactly as specified.

Padding

Padding is the space between the Auto Layout frame's edge and its contents. Figma allows you to set padding uniformly (all four sides equal) or independently (different values for top, bottom, left, and right). This is equivalent to CSS padding and produces the same visual effect: an inner buffer between the container boundary and the content inside it.

Hugging vs. Fixed vs. Fill

Each dimension of an Auto Layout frame (width and height) can be set to one of three behaviors. Hug means the frame shrinks or grows to exactly fit its contents, with no extra space. Fixed means the dimension is set to a specific pixel value and does not change regardless of content. Fill means the frame expands to fill the available space in its parent container, which is how a flexible column or row in a larger layout behaves.

  

8.4 Padding, Gaps, and Alignment

The precision with which you handle padding, gaps, and alignment separates designs that feel carefully crafted from those that feel casually assembled. These three properties govern the microspacing of your interface — the distances that users perceive subconsciously as polish or its absence.

Padding in Practice

Padding is the internal breathing room of a component. A button, for example, needs enough horizontal padding that the label does not feel cramped against the button's edges, and enough vertical padding that the button height feels comfortable to tap or click.

Common padding patterns on the 8-point grid include 8px vertical and 16px horizontal for compact buttons, 12px vertical and 24px horizontal for standard buttons, and 16px vertical and 32px horizontal for large prominent buttons. These values are not arbitrary — they are derived from years of collective design practice that has established what feels proportionally comfortable at each button size.

Input fields typically use 12 to 16px of vertical padding to achieve the standard 40 to 48px tap target height that mobile usability guidelines recommend.

Cards use larger padding, typically 16 to 24px on all sides for mobile contexts and 24 to 32px for desktop, to give their content sufficient room to breathe.

Gaps in Layout

Gap is the space between elements in a list, a row of cards, or a navigation menu. Unlike padding, which is internal, gap is the external distance between elements.

In vertical layouts (lists, menus, stacked content), a gap of 8px creates a compact feel, 16px creates a comfortable default feel, and 24px or more creates an airy, spacious feel. The choice between these depends on the density of information the design needs to convey.

Alignment Principles

Alignment is the invisible force that makes layouts feel organized. Every element on a screen should align to something: a column edge, another element's left edge, a center axis, or a baseline.

Figma's alignment controls appear in the right sidebar when multiple elements are selected. They allow you to align elements by their left edges, right edges, top edges, bottom edges, or center axes. The Tidy Up button (the crossed arrows icon) automatically distributes selected elements with equal spacing between them.

A design where elements are casually placed without deliberate alignment always looks unfinished, even to viewers who cannot articulate why. Consistent alignment builds the visual order that makes a design feel trustworthy.

8.5 Responsive Frames with Constraints

A design that looks perfect at one screen size but breaks at another is not a complete design. Responsive design thinking means considering how your layouts adapt to different viewport widths and heights. Figma supports this through a feature called Constraints.

What Are Constraints?

Constraints tell Figma how an element should behave when its parent frame is resized. They define the relationship between a child element and the edges of its container. You set constraints in the right sidebar under the Constraints section, which appears whenever an element is selected inside a frame.

Horizontal Constraints

The horizontal constraint has five options. Left anchors the element to the left edge of the frame, maintaining a fixed distance from that edge when the frame width changes. Right anchors to the right edge. Left and Right stretches the element: it maintains its distance from both edges simultaneously, so it grows and shrinks with the frame. Center keeps the element centered horizontally regardless of the frame width. Scale resizes the element proportionally as the frame width changes.

Vertical Constraints

Vertical constraints work identically but on the vertical axis. Top, Bottom, Top and Bottom, Center, and Scale provide the same range of behaviors in the vertical direction.

Practical Constraint Patterns

A navigation bar in a website design should typically have Left and Right horizontal constraints, so it stretches to fill the full width of any frame size. Its logo element, however, should have a Left constraint, staying anchored to the left edge. Its primary navigation links might have a Center constraint to stay centered. Its login button might have a Right constraint to stay anchored to the right edge.

A floating action button (the circular button common in mobile interfaces) is typically positioned at the bottom right of a screen. Setting its horizontal constraint to Right and vertical constraint to Bottom means it always sits at the bottom right corner, maintaining its specified distance from each edge, regardless of the screen dimensions.

Testing Responsiveness in Figma

To see your constraints in action, select the frame that contains your design and drag its edge handles to resize it. If your constraints are set correctly, the elements inside should reflow logically. If elements jump unexpectedly or maintain positions they should not, adjust the individual

Chapter 9

Components — The Heart of Figma

If there is one feature that defines Figma's power as a professional design tool, it is components. Components are the system that allows you to design once and use everywhere, maintaining perfect consistency across a product of any size. Understanding components deeply will transform not just how you use Figma, but how you think about design itself.

9.1 What Is a Component?

A component is a reusable design element. It is created once, stored in your file (or in a shared library), and used any number of times throughout your designs. When you change the original component, every instance of it in your project updates automatically.

Think about the experience of designing a large application with dozens of screens. Across those screens, there might be hundreds of buttons. Without components, if you decide to change the button's color from blue to green, you would need to find and update every single button individually. With components, you change the main component once, and all hundreds of buttons update in a single moment.

This is not just a convenience. It is a fundamental shift in how design scales. Components make large design systems possible. They make consistency enforceable rather than aspirational. They make design changes fast rather than laborious.

Components in Figma map directly to the component-based architecture of modern frontend frameworks like React, Vue, and Angular. This alignment between design components and code components makes developer handoff significantly more straightforward, because developers can look at a design system's component structure and understand how it translates to the code they need to write.

  

9.2 Creating Your First Component

Creating a component in Figma takes exactly one action. Design any element — a button, a card, an input field, a navigation bar — and then right-click on it and choose Create Component, or press Command + Option + K on Mac (Control + Alt + K on Windows).

The element transforms into a main component, indicated by a four-pointed star icon (❖) that replaces the standard frame icon in the layers panel, and a solid purple diamond outline visible on the canvas.

Designing a Button Component

Let us walk through creating a button component as a practical example.

Start by pressing F to activate the frame tool and drawing a frame on the canvas. In the right sidebar, add a fill of your primary brand color. Set the corner radius to 8 pixels. Then press T to add a text layer inside the frame, type "Button Label," and style it in white, Semi Bold, 16 pixels.

Now select the frame and press Shift + A to add Auto Layout. Set the horizontal padding to 24 pixels, the vertical padding to 12 pixels, and the spacing between items to 8 pixels (in case you later add an icon alongside the label).

At this point, you have a well-structured button frame. Right-click it and select Create Component. The button is now a main component. Every time you drag this component from your assets panel to a new location, you create an instance — a linked copy that inherits all the properties of the main component.

Naming Components

Figma uses forward slashes in component names to create organizational groupings. A component named Button/Primary appears in the assets panel under a "Button" group alongside components named Button/Secondary and Button/Ghost. This naming convention is not just cosmetic — it determines how components are organized in your assets panel and in shared libraries. Establishing a clear naming convention before you have many components will save significant reorganization effort later.

9.3 Main Components vs. Instances

The relationship between a main component and its instances is one of the most important concepts in Figma. Understanding it clearly will prevent confusion and unlock the full power of the component system.

The Main Component

The main component is the single source of truth. It defines the default appearance and structure of the component. There is exactly one main component for each component in your system. Changes made to the main component propagate automatically to all instances.

As a best practice, main components should be kept in a dedicated area of your file — typically on a separate page called "Component Library" or "_Components" (the underscore prefix causes it to sort to the top of the pages list). This keeps your working design pages clean and makes it easy to find and edit main components when needed.

Instances An instance is a copy of a main component placed in your design. To create an instance, drag the component from the assets panel onto your canvas, or copy the main component and paste it. Instances look identical to the main component by default.

What makes instances powerful is that they can be overridden locally without breaking their connection to the main component. If you have a button instance and you change the label text from "Get Started" to "Learn More," that override is maintained even when the main component is updated. The button's color, size, and structure will update with any main component changes, but your custom label text is preserved.

Structural overrides — changes to the component's layer organization, Auto Layout settings, or the addition of entirely new layers — are not preserved when the main component updates. This is intentional: the main component's structure is authoritative, and instances adapt to it.

Detaching Instances Right-clicking an instance and selecting Detach Instance severs its connection to the main component. The element becomes a regular frame with no component relationship. This is irreversible without using undo, so it should be done deliberately. Detaching is occasionally necessary when you need to make structural changes to a single instance that should not affect the main component or other instances.

9.4 Organizing Components Into a Library

As your component collection grows, organization becomes critical. A design system with dozens or hundreds of components needs a clear structure so that anyone using it can find what they need quickly and confidently.

The Assets Panel

All components in your current file are accessible through the Assets panel (the grid icon in the right sidebar, or press Option + 2). The panel displays components organized by their naming groups and by the file they belong to. Searching in the assets panel filters components by name in real time, which is the fastest way to find a specific component in a large library.

Structuring Your Component Pages

A common structure for a component library page in Figma is to organize components in section frames, with each section covering a category: Buttons, Form Elements, Cards, Navigation, Icons, Typography, and so on. Each section contains the main components, presented in a clean layout with adequate spacing between them and clear labels indicating the component name, its variants, and any relevant usage notes.

Shared Libraries

When you are working within a Figma team, you can publish your file's components as a shared library. Once published, any other file in the team can use your components as if they were local to that file. This is how design systems work at scale: one team maintains the component library, and all other designers across the organization access and use its components while the library team controls and updates the source of truth.

To publish a library, go to the main Figma menu, select Libraries, and click Publish next to your file. Team members can then enable your library in their own files through the same Libraries dialog.

9.5 Overriding Component Properties

The ability to customize instances without detaching them from their main components is what makes Figma's component system genuinely flexible for real-world design work. These customizations are called overrides.

Text Overrides

The simplest and most frequently used override is changing the text content of a text layer inside an instance. Double-click any text layer within a component instance and type new content. The text style (font, size, color) is inherited from the main component and updates with it, but the content you type is local to this instance.

Fill and Color Overrides

You can change the fill color of individual layers within a component instance without affecting other instances or the main component. Select a specific layer inside an instance (click once to select the instance, then click again to drill into it and select the specific layer) and change its fill in the right sidebar.

Visibility Overrides

You can toggle the visibility of individual layers within a component instance. This is particularly powerful when a component has optional elements — an icon next to a button label, for example, that should appear in some contexts but not others. By hiding the icon layer in specific instances, you get different visual results from the same underlying component without creating multiple separate components.

Component Properties

Figma's Component Properties system takes overrides to a structured level. When editing a main component, you can define formal properties: Boolean properties (show/hide a layer with a simple toggle), Text properties (expose a text layer's content as a named editable field), Instance Swap properties (allow one nested component to be replaced with another from a specified set), and Variant properties (switch between pre-designed variations of the component).

These properties appear in the right sidebar when an instance is selected, creating a clean, structured panel of customization options that does not require drilling into layers. This is how professional design systems expose flexibility to their users without overwhelming them with structural complexity.

Chapter 10

Styles and Design Tokens

Styles and design tokens are the connective tissue of a design system. They ensure that every decision you make about color, typography, spacing, and visual effects is captured, named, and consistently applied across your entire project. Without them, consistency is a matter of memory and discipline. With them, it becomes structural and automatic.

10.1 Text Styles

Text styles in Figma are saved typography configurations. Rather than manually setting the font family, weight, size, line height, and letter spacing every time you add a text element, you define these configurations once as named styles and apply them with a single click.

Creating a Text Style

Select any text element on your canvas that has been styled exactly as you want the style to capture. In the right sidebar, click the four-dot style icon next to the text properties section. Click the plus icon in the dropdown to create a new style. Give it a clear, systematic name.

A well-structured naming convention for text styles follows the purpose and scale of the text: Heading/H1, Heading/H2, Heading/H3, Body/Regular, Body/Large, Body/Small, Caption/Default, Label/Bold, Label/Regular. The forward slash creates groupings in the style picker, making it easy to find the right style quickly.

Applying Text Styles

To apply a saved text style, select any text element, click the style icon in the typography section of the right sidebar, and choose from the list of saved styles. The text element immediately adopts all of the defined properties.

Editing Text Styles

When you edit a text style (by right-clicking it in the styles panel and choosing Edit Style), every text element in your file using that style updates immediately. This is the practical power of styles: changing your H1 from 48px to 52px across an entire product takes one edit, not hundreds.

  

10.2 Color Styles

Color styles in Figma are saved color values that can be applied to fills, strokes, and effects across your entire project. They work on exactly the same principle as text styles: define once, apply anywhere, update everywhere.

Creating Color Styles

Apply a fill color to any shape, then click the four-dot style icon next to the Fills section in the right sidebar. Click the plus icon and name the style. Use a systematic naming structure that reflects both the color's identity and its intended use. A common approach is a two-tier naming convention: the color family and the shade value, such as Indigo/500, Indigo/100, Indigo/900, followed by semantic aliases that map these palette values to their functional roles: Brand/Primary maps to Indigo/500, Text/Primary maps to Neutral/900, Background/Surface maps to Neutral/50.

Semantic Color Naming

The semantic layer of color naming is what truly makes a color system professional and scalable. Rather than applying Indigo/500 directly to your primary buttons, you apply Brand/Primary. When your brand color changes from indigo to teal, you update the Brand/Primary style's value once, and every element using Brand/Primary updates across the entire product. Without semantic naming, you would need to find every instance of the color individually.

Using Color Styles for Consistency

Once your color styles are defined, applying them is a one-click action. Select any element, open the fill color picker, and click the grid icon at the top of the picker to switch from the spectrum view to the styles view. All your saved color styles appear organized by their naming groups. Click any style to apply it.

10.3 Effect Styles (Shadows, Blurs)

Effect styles capture and save visual effects — primarily drop shadows, inner shadows, and background blurs — as reusable styles. In any design system, shadows are as important to consistency as colors and typography: they establish the elevation hierarchy of the interface and should be applied systematically rather than arbitrarily.

Drop Shadows A drop shadow in Figma is defined by six parameters: X offset (horizontal distance), Y offset (vertical distance), blur radius (how soft the shadow edge is), spread (how much the shadow expands beyond the element's bounds), color (typically a semi-transparent near-black), and opacity.

A well-designed shadow system has multiple levels corresponding to different elevations. A very subtle shadow (2px Y offset, 4px blur, 8% opacity black) conveys a low-elevation element like a card resting on the page surface. A medium shadow (8px Y offset, 24px blur, 12% opacity black) conveys a floating element like a dropdown menu. A strong shadow (24px Y offset, 48px blur, 20% opacity black) conveys a high-elevation element like a modal dialog. Saving each of these as a named effect style (Shadow/Low, Shadow/Medium, Shadow/High) creates a consistent, semantic elevation system.

Inner Shadows Inner shadows are applied inside the element's boundary rather than outside. They create the impression of a recessed or inset surface. They are less common than drop shadows but appear in pressed button states, inset form fields, and certain illustration techniques.

Layer Blur and Background Blur Blur effects in Figma come in two varieties. Layer blur softens the element it is applied to, creating a frosted or out-of-focus appearance. Background blur (the effect behind frosted glass UI patterns) blurs everything visible behind the selected element. Background blur is widely used in modern interface design for translucent panels, navigation bars, and modal overlays that let the content beneath them show through in a blurred, softened form.

10.4 Grid Styles

Grid styles save your layout grid configurations as reusable presets. If you regularly work with a 12-column desktop grid and a 4-column mobile grid, you can save each as a named grid style and apply them to new frames with a single click rather than configuring the column count, margins, and gutters from scratch each time.

Creating Grid Styles

Apply a layout grid to any frame and configure it to your preferred settings. Then click the four-dot style icon next to the Layout Grid section in the right sidebar and save it with a descriptive name: Grid/Desktop-12col, Grid/Mobile-4col, Grid/Tablet-8col.

Applying Grid Styles Across a Project

Once saved, grid styles can be applied to any frame through the style picker. This is particularly valuable in large projects with many artboards: rather than checking each frame to ensure the grid is configured correctly, you apply the appropriate grid style and know it is right.

Baseline Grid Styles

Baseline grids saved as styles are particularly useful in typographically complex designs. A baseline grid set to 8 pixels creates a vertical rhythm reference that you can enable on any frame where you need to check that your text elements are sitting on consistent vertical positions.

10.5 Why Consistency Is Your Best Friend

Consistency in design is not rigidity. It is not the absence of creativity. It is the foundation that makes creativity legible.

When a user encounters a button in your application for the first time, they learn what buttons look like in your system. The next button they see — on a different screen, in a different context — should immediately read as a button because it shares the same visual language. This recognition is not accidental. It is the product of deliberate consistency in color, shape, size, and interaction. When it is present, users feel orientation and confidence. When it is absent, users feel confusion and friction, often without being able to articulate why.

Consistency Builds Speed

For designers, consistency is also a professional efficiency tool. When you have defined text styles, color styles, effect styles, and grid styles, you make design decisions much faster because most of the foundational choices have already been made systematically. You are not starting from scratch with every new screen. You are applying and adapting a system.

This speed compounds over the life of a project. The time investment in setting up a proper style system at the beginning of a project pays dividends in every subsequent design decision for the entire duration of the project.

Consistency Enables Change

Paradoxically, a consistent design system is also the thing that makes change least painful. Because every color is applied through a named style rather than a raw hex value, changing the brand's primary color across an entire product is a single-edit operation. Because every component shares a main component, redesigning a button takes one update. Consistency does not lock designs in. It makes them malleable at the system level while stable at the element level.

Consistency Communicates Craft

To the users of your product, a consistent design communicates that someone cared. It signals professionalism, intentionality, and quality. Users may not see the components panel or the color styles library. But they feel the result of it in every interaction. Consistency is invisible when it is present and glaringly obvious when it is absent.

Building and maintaining a consistent design system through Figma's styles and component features is not the glamorous part of design work. It is, however, the part that makes everything else work.

Designer's Note

Styles, components, and design tokens are not features you use when you become a professional designer. They are the practices that make you a professional designer. Start building your style system from the very first frame of every project, even small ones. The habit itself, independent of project size, will shape how you think about design at a structural level that no amount of visual skill alone can provide.

PART FOUR

BRINGING DESIGNS TO LIFE

Chapter 11

Prototyping Basics

Astatic design is a picture of an idea. A prototype is the idea in motion. Prototyping is the process of connecting your design screens with interactions and animations to simulate how a real product would behave when a user engages with it. It is one of the most powerful capabilities in Figma, and it is far more accessible than most beginners expect.

11.1 What Is a Prototype?

A prototype is an interactive simulation of a design. It allows someone to click through screens, trigger animations, scroll through content, and experience the flow of a product without any code having been written. It bridges the gap between a static visual design and a functioning application.

Prototypes serve several distinct purposes in the design process, and understanding these purposes helps you build the right kind of prototype for each situation.

User Testing

The most rigorous use of a prototype is user testing. By giving real users a clickable prototype and asking them to complete specific tasks, you can identify usability problems before a single line of production code is written. Finding that users cannot locate the checkout button in a prototype costs nothing to fix. Finding the same problem after development is complete costs significantly more in both time and money.

Stakeholder Presentation

A clickable prototype is a far more compelling communication tool than a slideshow of static screens. When presenting a new product concept or a redesign to stakeholders, a prototype allows them to experience the design rather than merely observe it. This leads to more specific, actionable feedback and builds confidence in the design direction.

Developer Briefing

Prototypes communicate interaction behavior and animation intent in ways that static designs simply cannot. Showing a developer a prototype of a transition animation is dramatically more precise than trying to describe it in written annotations. The prototype becomes a behavioral specification alongside the visual design.

Design Exploration

Prototyping can also be a design tool in itself. Building a rough interactive prototype early in the design process forces you to think about navigation structure, user flows, and interaction states before you invest significant time in visual polish. Problems that are invisible in static designs often become obvious as soon as you try to connect the screens.

  

11.2 Connecting Frames With Interactions

Building a prototype in Figma begins with switching from the Design tab to the Prototype tab in the right sidebar. This single action transforms the workspace: blue connection handles appear on the edges of selected elements, and the right sidebar updates to show interaction controls.

The Prototype Tab

When you click the Prototype tab in the right sidebar with nothing selected, you see global prototype settings: the device frame that will appear when the prototype is presented, the background color behind the device, and the starting frame (the screen the prototype begins on when someone opens the prototype link).

Click the device dropdown to choose from a library of phone, tablet, desktop, and watch frames. Selecting a device frame wraps your prototype presentation in a realistic device mockup, which makes presentations to stakeholders significantly more convincing.

Creating a Connection

Select any element on your canvas — a button, a navigation item, a card, a back arrow — that should trigger a navigation to another screen. A small blue circle with a plus icon appears on the right edge of the element when you hover over it. Click and drag from this circle to the destination frame. A blue arrow appears, representing the interaction connection.

When you release the drag over a destination frame, Figma automatically creates an interaction with default settings. These settings are displayed in the right sidebar and can be fully customized.

Setting the Trigger

The trigger defines what user action causes the interaction to fire. The most common trigger is On Click, which activates when the user clicks or taps the element. Other available triggers include On Drag (the user drags the element), While Hovering (the interaction fires when the cursor is over the element — useful for hover states on desktop), While Pressing (fires while the element is actively being pressed), Key/Gamepad (fires when a specific keyboard key is pressed), Mouse Enter and Mouse Leave (fires when the cursor enters or leaves the element's bounds), and After Delay (fires automatically after a specified time without user input, useful for splash screens and auto-advancing onboarding flows).

Setting the Action

The action defines what happens when the trigger fires. Navigate To sends the user to another frame. Open Overlay places a frame on top of the current screen without fully navigating away. Swap Overlay replaces the current overlay with another. Back navigates to the previously viewed frame, recreating the browser back button behavior. Close Overlay dismisses the current overlay. Scroll To smoothly scrolls the current frame to a specified element's position.

11.3 Triggers and Animations

The connection between frames is only half of an interaction. The other half is the animation — the visual transition that plays as the prototype moves from one state to another. Figma gives you a rich set of animation options that can dramatically improve the realism and communication value of your prototype.

Transition Types

When an interaction is selected in Prototype mode, the animation controls appear in the right sidebar below the trigger and action settings.

Instant removes all animation. The transition happens immediately with no visual motion. This is useful for rapid prototypes where animation fidelity is not the priority.

Dissolve fades the destination frame in over the current frame, creating a gentle cross-fade transition. It is visually neutral and appropriate for transitions that do not have a strong directional implication.

Move In slides the destination frame into the viewport from one of four directions (left, right, top, bottom). It implies directional navigation: moving right to go deeper, moving left to go back, moving up to reveal content below, moving down to reveal a drawer.

Move Out slides the current frame out of the viewport in the specified direction. Often paired with Move In on connected screens.

Push combines Move In and Move Out: the current frame slides out while the destination slides in from the opposite direction, creating the sensation of physically navigating through a stack of screens.

Slide In and Slide Out work similarly to Move but with the screens overlapping during the transition rather than replacing each other.

Easing Curves

Below the transition type selector is the easing curve control. Easing determines the acceleration profile of the animation: does it start fast and slow down? Start slow and accelerate? Move at a constant speed?

Linear means constant speed throughout, which looks mechanical and unnatural for most UI animations. Ease In starts slowly and accelerates, appropriate for elements leaving the screen. Ease Out starts fast and decelerates, appropriate for elements entering the screen (mimicking physical objects that slow as they arrive). Ease In and Out combines both, creating a natural arc that feels organic. The Custom option allows you to define the exact cubic bezier curve of the easing, providing precise control for more sophisticated animation work.

Duration

Duration controls how long the transition animation takes, measured in milliseconds. The default is 300ms, which is a widely accepted standard for UI transitions — fast enough not to feel sluggish, slow enough for the motion to be perceived as intentional. Durations below 150ms often feel too abrupt. Durations above 500ms often feel slow unless the design intentionally calls for a more deliberate, expressive pace.

11.4 Scrolling and Overlays

Two of the most important interaction patterns in modern mobile and web interfaces are scrolling content and overlay elements. Figma supports both natively, and implementing them correctly makes your prototypes dramatically more realistic.

Scrolling Frames

Many mobile screens contain more content than fits in the visible viewport. A product listing page, a news feed, a settings screen — all of these scroll vertically to reveal additional content below the fold. In Figma, you implement scrolling by making the content inside a frame taller than the frame itself, then enabling scrolling on that frame.

To create a scrolling frame, first set your frame to the device screen height (for example, 852 pixels for iPhone 16 Pro). Then, place all of your content inside this frame, allowing it to extend beyond the bottom edge. The content might total 2000 pixels in height. Select the frame and in the right sidebar under the Prototype tab, find the Overflow Behavior dropdown. Change it from No Scrolling to Vertical Scrolling.

In the prototype preview, the frame now scrolls naturally when you drag upward with your mouse, exactly as a real mobile screen would scroll with a finger swipe.

Horizontal scrolling works identically but in the horizontal direction. It is used for carousels, image galleries, tab bars that extend beyond the screen width, and chip/filter rows that scroll sideways.

Overlays

An overlay is a frame that appears on top of the current screen without navigating to a new one. Common overlay patterns include modal dialogs, bottom sheets, dropdown menus, tooltips, and notification toasts.

To create an overlay interaction in Figma, select the trigger element (a button, for example) and create a prototype connection. Instead of setting the action to Navigate To, set it to Open Overlay. Choose the destination frame as the overlay content.

Additional overlay settings let you control where the overlay appears on screen (centered, top, bottom, or manually positioned), whether the background behind the overlay dims, whether clicking outside the overlay closes it, and whether the overlay background is transparent (allowing the content beneath to show through).

Bottom sheet overlays — the panels that slide up from the bottom of a mobile screen — are created with Open Overlay, positioned at the bottom of the screen, with a slide-in-from-bottom animation and a dimmed background. This is one of the most commonly used interaction patterns in mobile UI design and learning to prototype it correctly is an important practical skill.

11.5 Presenting Your Prototype

Once your prototype is built, sharing and presenting it is straightforward. Figma generates a shareable link that anyone can open in a browser to interact with the prototype, with no Figma account required.

The Present Button

In the top right of the Figma toolbar, click the Play button (the right-pointing triangle icon) to launch the prototype in presentation mode. This opens a new browser tab or window showing the prototype in the device frame you selected, centered against the background color you defined.

In presentation mode, the Figma interface disappears and only the prototype is visible. Clicking interactive elements triggers the interactions you have defined. The prototype behaves as a standalone experience.

Sharing Prototype Links

Click the Share button in the toolbar while in the Prototype tab to generate a shareable link. You can control access settings: anyone with the link can view, or access can be restricted to specific people. The view-only link allows recipients to interact with the prototype and leave comments but not edit the file.

Prototype links are ideal for remote user testing, asynchronous stakeholder review, and sharing work with developers who need to understand interaction behavior.

Prototype Presentation Mode Controls

In presentation mode, the R key restarts the prototype to the starting frame. The F key toggles fullscreen. Pressing Escape returns to the Figma editor. These keyboard shortcuts are worth memorizing for live presentations where smooth navigation between the prototype and the editor may be necessary.

Recording Prototype Flows

While Figma does not have a built-in screen recorder, the prototype link can be opened in any screen recording software to capture walkthroughs. For user testing sessions, tools like Maze, UserTesting, and Lyssna integrate with Figma prototypes to automatically record sessions, collect metrics like time-on-task, and aggregate feedback across multiple test participants.

  

Chapter 12

Advanced Prototyping

The basic prototyping tools covered in Chapter 11 are powerful enough to communicate most design ideas clearly. But Figma's advanced prototyping capabilities take that communication to a level of realism that can genuinely blur the line between a design prototype and a working application. This chapter covers the features that make that possible.

12.1 Smart Animate, Smooth Transitions Made Easy

Smart Animate is Figma's most impressive prototyping feature. It automatically detects matching layers between two connected frames and animates the differences between them — size, position, rotation, opacity, and other properties — creating smooth, physics-feeling transitions without any manual animation keyframing.

How Smart Animate Works

When you select Smart Animate as the transition type for an interaction, Figma compares the layers in the starting frame to the layers in the destination frame. Any layers that share the same name and layer hierarchy are treated as the same object at different states. Figma then automatically generates an interpolated animation between those states.

If a button in Frame A is positioned at the bottom of the screen and the same button (same layer name, same component) in Frame B is positioned at the top of the screen, Smart Animate will smoothly slide the button from bottom to top as the transition plays. If an element in Frame A is 100px wide and the same-named element in Frame B is 300px wide, Smart Animate will animate the width expansion. If an element in Frame A is fully opaque and in Frame B is invisible, Smart Animate will fade it out.

Practical Application: Expanding Card

A compelling example of Smart Animate in practice is an expanding card interaction. In Frame A, you have a small summary card at the bottom of the screen. In Frame B, you have the same card expanded to full screen, showing additional detail content. The card elements share identical layer names in both frames. When connected with Smart Animate and an On Click trigger, tapping the card produces a beautiful expansion animation where the card organically grows to fill the screen, with its content elements repositioning fluidly. This interaction — ubiquitous in modern mobile apps — takes only minutes to prototype in Figma with Smart Animate.

Layer Naming Is Critical

Smart Animate only works when layer names match between frames. If the card frame in Frame A is named "CardContainer" and the expanded card in Frame B is named "ExpandedCard," Figma will not recognize them as the same object and will default to a standard dissolve transition. This makes disciplined layer naming not just a organizational habit but a technical requirement for advanced prototyping.

12.2 Component States and Variants

Variants are one of Figma's most powerful features for building realistic interactive prototypes. They allow you to create multiple versions of a component — representing different visual states — and group them into a single organized system that can be switched between in prototypes and design work.

What Are Variants?

A variant is a version of a component that differs in one or more defined properties. A button component might have variants for its Type (Primary, Secondary, Ghost), its Size (Small, Medium, Large), and its State (Default, Hover, Pressed, Disabled, Loading). All of these variants belong to the same component set — they are all "the same button" in different conditions.

Creating a Component Set

To create variants, first build your main component in its default state. Then duplicate it and modify the duplicate to represent a different state. Select both components and click the Combine as Variants button that appears in the right sidebar. Figma places both components inside a single dashed purple variant container called a component set.

In the right sidebar, you can define the variant property names and values. A button component set might have a property named "State" with values "Default," "Hover," "Pressed," and "Disabled," and a property named "Type" with values "Primary," "Secondary," and "Ghost." Figma creates a grid of all possible combinations, and you design each one within the component set frame.

Using Variants in Prototypes

The real power of variants emerges in prototyping. When an instance of a variant component is selected in Prototype mode, you can create interactions that trigger a Change To action, switching the instance from one variant to another. A button in its Default state, when hovered, can Change To its Hover variant. When clicked, it can Change To its Pressed variant, then navigate to the next frame.

This creates interactive components that respond to user input with accurate visual state changes, producing prototypes that behave nearly identically to the real implementation.

12.3 Interactive Components

Interactive components extend the variant system to create components that are self-contained interactive objects — components whose internal state changes happen automatically within the component, without needing to define interactions on every individual instance.

The Difference From Regular Variant Interactions

Without interactive components, making a checkbox component that visually toggles between checked and unchecked requires placing the checkbox in every frame of your prototype and defining Change To interactions on every individual instance. If your prototype has twenty screens with a checkbox, that is twenty separate interaction definitions.

With interactive components, you define the toggle interaction once on the main component. Every instance of that component throughout the prototype automatically inherits the toggle behavior. Adding interactive behavior to your designs becomes as simple as placing components — no additional prototype wiring required.

Creating Interactive Components

To add interactions to a component, enter the main component by double-clicking it (not an instance). Switch to the Prototype tab. Select the element inside the component that should trigger the interaction (the checkbox box itself, for example). Create a connection from this element to another variant in the same component set (the checked variant). Set the trigger and animation.

Exit the component. Now every instance of this component in your prototype will respond to clicks by toggling between states automatically.

Common Use Cases

Checkboxes and radio buttons are the most obvious application. A toggle switch that turns on and off. A star rating component that fills stars as they are clicked. An accordion that expands and collapses. A tab bar where the active tab highlights. A like button that animates between unliked and liked states. All of these are interaction patterns that appear dozens of times across a typical application's screens, and interactive components make prototyping all of them dramatically more efficient.

  

12.4 Conditional Logic With Variables

Variables represent one of Figma's most significant expansions beyond visual design into genuine interaction design territory. They allow prototypes to remember information, make decisions, and behave differently based on what has happened previously in the user's session.

What Are Variables?

A variable in Figma is a named container that stores a value. That value can change during a prototype session in response to user interactions, and other elements in the prototype can respond to that value. Figma currently supports four variable types: Boolean (true or false, useful for toggling states), Number (a numeric value, useful for counters and progress), String (a text value, useful for names, labels, and dynamic content), and Color (a color value, useful for theming).

Creating Variables Variables are created in the Local Variables panel, accessible from the main Figma menu. Click the Variables section and then the plus icon to create a new variable. Give it a descriptive name (IsLoggedIn, CartItemCount, SelectedTab, ThemeColor) and set its type and default value.

Using Variables in Conditions

Once variables exist, you can create conditional interactions: interactions that only fire if a specific condition is true. For example, a "Proceed to Checkout" button might have two conditional interactions: If CartItemCount is greater than zero, Navigate To Checkout Screen. If CartItemCount equals zero, Open Overlay Empty Cart Message.

This means the prototype behaves differently depending on the application state, much like a real application would. A single button can have intelligent behavior that reflects real UX logic without any code.

Setting Variable Values

Interactions can set variable values as their action. A quantity increment button can trigger an interaction with the action Set Variable — CartItemCount — to CartItemCount plus one. This increments the counter variable each time the button is pressed. Connecting a text element to display the CartItemCount variable makes a dynamic counter that actually updates in the prototype.

12.5 Building a Clickable App Demo

Everything covered in this chapter comes together in the process of building a complete clickable app demo — the kind of polished, interactive prototype you would present to a client, use in a job interview portfolio, or hand off to a development team as a behavioral specification.

Planning the Flow

Before building any interactions, map out the user flow you intend to prototype. A complete app demo does not need to cover every possible screen — it needs to cover the primary user journey clearly. For a food delivery app, this might be: Splash Screen → Onboarding → Home → Restaurant Search → Restaurant Detail → Menu Item Selection → Cart → Checkout → Order Confirmation.

Sketch this flow as a simple diagram on a Figma page (or on paper) before touching the prototype connections. Knowing where every arrow should go before you start connecting prevents the confusing tangle of crossing connection arrows that plagues many beginners' prototype files.

Setting Up the Starting Frame

In the Prototype tab with nothing selected, set your starting frame to the first screen in the flow (typically the splash screen or the home screen for a logged-in demo). This ensures the prototype link opens at the correct entry point.

Building Layer by Layer

Connect frames in order, following the planned flow. Test each connection as you make it by launching the prototype and clicking through to verify the interaction behaves as expected before moving on to the next. Catching errors immediately keeps the debugging process manageable.

Adding Polish

Once all primary connections are functional, add the animations that make the prototype feel premium: Smart Animate transitions between related screens, carefully tuned easing curves, appropriate animation durations (between 250 and 400ms for most UI transitions), and micro-interactions on buttons and interactive elements using interactive components.

Sharing the Demo

Generate the prototype link and open it in a private browser window before sharing it. Experience it exactly as your audience will — in the device frame, starting from the first screen, without any editing UI visible. This perspective often reveals issues invisible from inside the editor: interactions that lead to unexpected dead ends, animations that feel too slow at actual interaction speed, or screens that are missing essential navigation options.

PART FIVE

COLLABORATION AND HANDOFF

Chapter 13

Working With a Team

Design has never been a purely solitary activity. Even the most independent designer eventually shares work with clients, collaborators, developers, and stakeholders. Figma was built from the ground up with collaboration as a core feature rather than an afterthought, and understanding how to use its collaboration tools effectively will make you a significantly more effective member of any team.

13.1 Sharing Files and Setting Permissions

Sharing in Figma is controlled at two levels: the file level and the team/project level. Understanding both gives you precise control over who can access your work and what they can do with it.

Sharing a File

Click the Share button in the top right of the Figma toolbar to open the sharing panel. Here you can invite specific people by email address or generate a link that anyone can use to access the file. Each access method has independent permission settings.

Permission Levels

Can View is the most restricted permission. Recipients can see the design, navigate the canvas, inspect element properties in the Inspect tab, leave comments, and interact with prototypes. They cannot edit the design, move elements, or change any design properties. This is the appropriate permission level for developers receiving designs, clients reviewing work, and stakeholders who need to see progress without the risk of accidentally modifying anything.

Can Edit grants full editing access to the file. The recipient can create and delete frames, modify any design element, add and remove pages, publish components to the library, and manage the file's content entirely. This is appropriate for design collaborators and team members who are actively contributing to the design work.

Link Sharing

The link sharing settings determine who can access the file through a URL. Anyone with the link can view gives open access to anyone who receives the link — appropriate for sharing prototypes publicly or with external stakeholders. Invite only restricts access to only those who have been explicitly invited by email, providing greater control for sensitive or confidential work. Only people invited can edit is the most restrictive option, combining link-based access with individual permission management.

Team and Project Level Sharing

In Figma teams (available on paid plans), files within a project inherit access settings from the project. Setting a project to viewable by the whole team means all team members can see and interact with any file in that project without individual file sharing being required. This reduces administrative overhead in collaborative environments significantly.

  

13.2 Real-Time Collaboration

Real-time collaboration is the feature that sets Figma apart most dramatically from every design tool that preceded it. Multiple people can work inside the same file simultaneously, with each person's actions visible to all others in real time.

Seeing Collaborators

When another person has your file open, their avatar (a colored circle with their initials or profile photo) appears in the top right of the Figma toolbar. The color of each collaborator's avatar is unique to that person's session and matches the color of their named cursor on the canvas. If Maya is working with a purple avatar, her cursor appears as a purple arrow labeled "Maya" moving across the canvas.

Following a Collaborator

Clicking on any collaborator's avatar in the toolbar activates Follow Mode for that person. Your canvas view immediately jumps to wherever they are on the canvas and follows their movements in real time. This is invaluable during design reviews and pair design sessions: one person drives while others follow, seeing exactly what the driver sees without any screen sharing application.

Cursor Chat

Figma includes a Cursor Chat feature (activated with the C key) that allows temporary messages to appear next to your cursor on the canvas. Type a short message and it appears floating beside your cursor, visible to all collaborators, then fades after a few seconds. This is useful for quick, contextual communication ("looking at the header now," "what's the spacing here?") during live collaborative sessions without interrupting the design work to switch to a messaging application.

Multiplayer Editing Considerations

Working simultaneously in the same file with others requires some coordination norms. Communicating which areas of the canvas you are working on prevents two designers from inadvertently editing the same element. Using pages effectively separates work-in-progress areas from reviewed and approved screens. Establishing a convention for layer naming and component organization ensures that collaborators can understand each other's work without explanation.

13.3 Leaving Comments and Feedback

Comments are Figma's built-in system for design feedback. Rather than collecting feedback in email threads, shared documents, or verbal conversations, Figma allows every stakeholder — with nothing more than a view-only link — to pin specific, precise comments directly onto design elements.

Adding Comments

Press C on the keyboard (or click the comment bubble icon in the toolbar) to enter comment mode. In comment mode, clicking anywhere on the canvas places a comment pin at that exact location. A text field appears for you to type your comment. Press Enter or click the send button to post it.

Comments can be placed on the canvas generally or directly on specific elements. Zooming in before placing a comment ensures the pin lands on the exact pixel you intend to address. For precise feedback on small elements like icons or form field details, zooming to 200% or higher before commenting is good practice.

Threads and Replies

Each comment becomes a thread. Collaborators can reply to any comment, creating a focused conversation about that specific design element. This is dramatically more organized than email feedback, where references to "the blue thing in the second screen" require interpretation. In Figma, the comment is visually anchored to exactly what is being discussed.

Resolving Comments

When a comment's issue has been addressed, clicking the checkmark on the comment thread marks it as resolved. Resolved comments are hidden from the main view but remain accessible through the Resolved filter in the comments panel. This creates a natural audit trail of feedback received and changes made.

The Comments Panel

Opening the comments panel (the speech bubble icon in the right sidebar) shows all active comments in the file in a chronological list. Clicking any comment in the panel jumps the canvas view to that comment's location, making it easy to work through feedback systematically without hunting across a large canvas.

13.4 Version History, Your Safety Net

Version history is Figma's automatic backup system. Every meaningful change to a file is saved to version history, creating a timeline of the file's evolution that you can browse, preview, and restore from at any time.

Accessing Version History

Version history is accessed through the main Figma menu: File > Show Version History (or Command + Option + S on Mac). The right sidebar transforms into a timeline of saved versions, each listed with a timestamp and the name of the person who made the changes.

Automatic vs. Named Versions

Figma saves versions automatically at regular intervals and whenever significant editing activity occurs. These automatic saves provide comprehensive coverage of your file's history. Additionally, you can manually save a named version at any point using File > Save to Version History. Named versions are particularly useful for capturing milestones: "Version 1 — Stakeholder Review,"

"Version 2 — Post-Feedback Revisions,"

"Version 3 — Developer Handoff."

Named versions are visually distinguished in the history timeline and are easier to locate when you need to reference or restore a specific milestone.

Previewing Past Versions

Clicking any version in the timeline opens a read-only preview of the file at that point in time. You can navigate the canvas, zoom in and out, and examine the design exactly as it existed at that moment. This preview does not affect the current file — it is purely observational.

Restoring a Version

If you need to revert the file to a previous state, click Restore This Version in the version preview. The file returns to the state of that version. Importantly, Figma saves the current state as a new version before restoring, so you can always undo the restore if needed. Nothing in version history is ever permanently lost.

13.5 Figma for Solo Designers vs. Teams

Figma is exceptional for both solo designers and large collaborative teams, but the way you use it optimally differs between these contexts. Understanding these differences will help you develop habits that scale appropriately as your work evolves.

The Solo Designer's Workflow

As a solo designer, you have complete control and no coordination overhead. Your primary organizational challenge is your relationship with your future self: will you be able to understand this file when you return to it after two weeks away?

The habits that matter most for solo designers are rigorous layer naming (generic default names become meaningless quickly), consistent page organization (a clear structure for wireframes, final designs, components, and assets), regular named version saves at key milestones, and a personal component library that you build and refine across projects. Many solo designers maintain a "master kit" file containing their component library, color styles, and text styles that they duplicate as the starting point for each new project.

The Team Workflow

Teams require all of the organizational discipline of solo design plus an additional layer of coordination: your file must be understandable and navigable not just to your future self but to colleagues who may not have been present during the design decisions.

Team-specific best practices include establishing naming conventions as a team before starting a project (not after), using Figma's branching features (available on paid plans) for experimental work that is not ready to enter the main file, publishing shared component libraries that the whole team uses rather than duplicating components across individual files, using designated review frames to present work in progress for team critique, and maintaining a changelog page in important files noting what changed, why, and when.

Scaling From Solo to Team

Many designers begin as solo practitioners and eventually join or build a team. The transition is significantly smoother if good organizational habits are already in place. A solo designer who names layers systematically, uses components consistently, and saves named versions at milestones can onboard collaborators to their workflow quickly. A solo designer who has worked in casual disorganization faces a more significant challenge when collaboration becomes necessary.

The best time to develop team-ready habits is before you need them.

Chapter 14

Developer Handoff

Adesign that never gets built is just a picture. The moment your design enters the hands of a developer, a new phase of the product's life begins — one where every decision you made as a designer is interpreted, translated, and implemented in code. Understanding how developers use Figma, and designing your files with developer needs in mind, is one of the most professionally valuable skills a designer can develop.

14.1 How Developers Use Figma

Developers who receive a Figma file are typically trying to answer a specific set of questions. What are the exact dimensions of this element? What font size, weight, and line height is this text? What are the precise color values? What happens when this button is in its hover state? How does this screen transition to the next one? How do I export this icon as an SVG?

A well-prepared Figma file answers all of these questions clearly and without ambiguity. A poorly prepared file — even one that looks visually stunning — forces developers to guess, estimate, or interrupt the designer with questions, slowing down the entire development process.

The Developer's Mental Model

Developers think in terms of components, properties, and states. When a developer looks at a Figma design, they are mentally mapping what they see to the code structures they will write: a div with padding, a flexbox row with a gap, a button with four states (default, hover, focus, disabled), a text style with specific CSS properties.

Figma's component and style system maps remarkably well to this mental model. A Figma component corresponds to a React component, a Vue component, or a reusable HTML/CSS pattern. A Figma text style corresponds to a CSS class. A Figma color style corresponds to a design token or CSS custom property. The closer your Figma file's structure is to how it will be implemented in code, the smoother the handoff will be.

Figma Dev Mode

Figma offers a dedicated Dev Mode interface (accessed by clicking the code icon in the toolbar or by the person with an active Developer seat in the team plan). Dev Mode transforms the Figma interface to prioritize the information developers need: code snippets, exact measurements, design token references, and asset export options are all surfaced prominently. As a designer, understanding what Dev Mode shows developers helps you prepare your files appropriately.

14.2 Inspect Mode Explained

The Inspect tab is the primary interface developers use when examining a Figma file. Switching to this tab (visible in the right sidebar alongside Design and Prototype) transforms the properties panel into a developer-focused information display.

Selecting Elements for Inspection

When a developer (or designer) selects any element in the Figma file while the Inspect tab is active, the panel immediately displays all of the relevant technical properties for that element in a format optimized for implementation reference.

Dimensions and Position

At the top of the Inspect panel, the element's width, height, and position values are displayed. These are absolute pixel values, exactly as they appear in the design. Below these basic dimensions, spacing values are shown relative to the element's siblings and parent container — the gaps and margins that define how the element relates spatially to everything around it.

Typography Details

For text elements, the Inspect panel displays every typographic property: font family, font weight, font size, line height, letter spacing, text alignment, and text color. These values are shown in a format immediately translatable to CSS: font-family, font-weight, font-size, line-height, letter-spacing, text-align, color.

Fill and Color Values

Color fills are displayed in multiple formats simultaneously: HEX, RGB, HSL, and if the color is connected to a named color style, the style name is shown as well. This allows developers using different color system conventions to use whichever format their codebase requires.

Code Snippets

Figma generates CSS code snippets for selected elements that developers can copy directly. For a button component, this might include the background-color, border-radius, padding, font properties, and box-shadow. These snippets are not always complete implementation-ready code — they represent the visual properties of the element as designed — but they are an excellent starting reference that significantly reduces the time developers spend translating visual designs into CSS values.

14.3 Exporting Assets (PNG, SVG, PDF)

Not everything in a design is described through CSS properties. Images, icons, illustrations, and custom graphics need to be exported as files that developers can include directly in the product. Figma's export system is flexible and covers the full range of asset formats needed for modern web and mobile development.

Setting Up Exports

Select any element, frame, component, or group on the canvas. Scroll to the Export section at the bottom of the Design panel in the right sidebar. Click the plus icon to add an export setting. A row appears with three controls: a scale multiplier, a format selector, and an optional suffix field.

Scale Multipliers

The scale multiplier (1x, 2x, 3x) determines the resolution of the exported asset relative to its design dimensions. A button designed at 160 by 44 pixels exported at 1x produces a 160 by 44 pixel PNG. The same button exported at 2x produces a 320 by 88 pixel PNG. The same at 3x produces a 480 by 132 pixel PNG.

For web development, 2x exports are standard for supporting high-density (Retina) displays without providing unnecessarily large files. For iOS development, all three scales (1x, 2x, 3x) are typically required. For Android development, multiple density-specific exports are needed, though Figma can generate these through custom scale values.

Format Selection

PNG is the appropriate format for complex graphics, photographs, and elements with transparency that cannot be rendered as vectors. It is the most widely supported raster format for both web and mobile contexts.

SVG is the correct format for icons, logos, illustrations, and any graphic built from vectors. SVG files are resolution-independent, scale to any size without quality loss, and can be styled with CSS in web contexts. Always prefer SVG over PNG for vector graphics.

JPG is appropriate for photographic content where fine transparency control is not needed. JPG files are typically smaller than PNG at equivalent perceived quality, making them preferable for large background photographs.

PDF export is primarily useful when designing for print contexts or generating design documentation.

Batch Exporting

To export multiple elements simultaneously, select all of them (using Shift-click or by dragging a selection box), add export settings, and click Export. All selected elements export as individual files in a single operation, which is efficient when preparing a complete icon set or a full set of screen assets.

  

14.4 Writing Design Annotations

Even with the best-organized Figma file and the most comprehensive Inspect panel information, some design decisions require explanation that visual design alone cannot communicate. Annotations are written notes placed directly on the canvas that provide context, specify behaviors, and document decisions that are not self-evident from the visual design.

What Annotations Should Cover

Good annotations explain the why, not just the what. The what (dimensions, colors, spacing) is available through the Inspect panel. Annotations add value when they explain interaction behaviors not visible in static designs (on scroll, this header becomes sticky and reduces in height), edge cases (if the username exceeds 20 characters, truncate with an ellipsis), content rules (minimum one item, maximum six items in this list), accessibility requirements (this button requires a minimum contrast ratio of 4.5:1 — do not change the text color), animation specifications (the transition duration is 300ms with an ease-out curve), and API dependency notes (this section only appears when the user has connected their payment method).

Building an Annotation System in Figma

Create a consistent annotation style that is visually distinct from your design content so developers can immediately distinguish annotations from design elements. A common approach uses a bright yellow or orange background color, a specific monospace or sans-serif font, and a standardized callout line or arrow pointing to the relevant element. Save this annotation style as a component so that all annotations across your file are visually consistent and easy to spot.

Place annotations on a dedicated layer that can be hidden when not needed, keeping the canvas clean for design review while making the annotations easily accessible for developer reference.

When Annotations Are Not Necessary

Annotations take time to write and maintain. Do not annotate things that are self-evident from the design or available through standard Inspect panel information. The dimensions of a button, the color of a heading, the border radius of a card — these do not need annotations. What needs annotation is everything that requires judgment, context, or explanation

14.5 Making Your Files Developer-Friendly

A developer-friendly Figma file is organized, consistent, annotated where necessary, and respectful of the developer's time. It does not require a walkthrough meeting to understand, and it does not contain ambiguity that forces guesswork. Building this kind of file is a skill, and like all skills, it improves with deliberate practice and feedback from the developers who actually use your files.

Use Real Content

Lorem ipsum placeholder text and grey box image placeholders communicate that the design is incomplete. Use realistic content — actual product names, realistic description lengths, real-world data quantities — so that developers can assess how the design will actually behave with real information. Edge cases like very long names, empty states, and error states should be designed and present in the file, not left to the developer's imagination.

Maintain a Single Source of Truth

Avoid having multiple versions of the same screen scattered across different pages or files. If a screen has been revised, archive or delete the previous version rather than leaving it alongside the new one. A developer encountering two versions of the same screen will be forced to guess which is current. Name your pages and frames clearly: "Checkout — V3 Final" is better than "Checkout" when there are previous versions, and deleting outdated versions is better still.

Use Components Consistently

Every button in your file should be an instance of the button component. Every input field should be an instance of the input component. Developers looking at your file should be able to see through the design to the underlying system. When they see a component instance, they know what React component to use. When they see a one-off custom element that looks like a button but is not a button component, they face unnecessary ambiguity.

Organize Your Layers

Rename every layer. Group related elements. Use frames rather than groups for layout containers. Name frames according to the content they represent, not the default Frame 427. A developer who needs to inspect a specific element should be able to find it in the layers panel in under ten seconds. If your layers panel looks like a list of numbered rectangles and groups, it will slow down every developer who ever opens your file.

Test Your Own Handoff

Before considering a file ready for handoff, open the Inspect tab yourself and try to extract the information a developer would need. Click on elements throughout the file. Is everything named? Are all colors connected to named styles? Are all text elements using text styles? Are components used consistently? Are measurements clear? If you encounter ambiguity or disorganization as a designer who built the file, a developer who did not build it will encounter more.

Designer's Note

The quality of a design handoff is a reflection of professional respect. A developer's time is as valuable as yours. When you invest the extra hour to clean up your file, name your layers, write clear annotations, and test your own Inspect panel, you are not doing extra work — you are completing the work. A design delivered to development is only finished when it can be implemented without unnecessary questions.

PART SIX

REAL-WORLD PROJECTS

The chapters in Parts One through Five gave you the knowledge. Part Six gives you the experience. There is a significant difference between understanding how a tool works and actually using it to build something real. These four projects are designed to close that gap.

Each project builds on the skills from previous chapters and introduces new challenges that only emerge when you are designing something complete rather than practicing isolated techniques. You will make decisions that have no single correct answer. You will encounter moments where the design does not look right and you will have to trust your judgment to fix it. You will finish each project with something tangible — a file you can put in your portfolio, show to a client, or hand to a developer.

Work through the projects in order if you can. Each one introduces conventions and habits that the next project builds upon. But if a particular project speaks more directly to your goals, it is perfectly reasonable to start there and return to the others.

One rule applies to all four projects: do not skip the setup steps. The temptation when starting a new design is to jump straight into the visual work. Resist it. The setup — the frame dimensions, the grid, the text styles, the color palette — is the foundation. A beautiful design built on a disorganized foundation is fragile. Build it right from the beginning.

Chapter 15

Project 1: Design a Mobile App Screen

Project Brief

You are designing the Home screen for a personal finance app called Finio. Finio helps users track their spending, monitor their savings goals, and get a clear picture of their financial health at a glance. The Home screen is the first thing users see after logging in. It needs to be clear, trustworthy, and easy to scan.

The design should feel modern and professional — the kind of app a user would trust with their financial information. It should not feel clinical or intimidating. The goal is financial clarity, not financial anxiety.

15.1 Setting Up the File

Open Figma and create a new design file. Name it "Finio — Mobile App" immediately. Create four pages: Wireframes, Final Design, Components, and Assets. You will work across all four before the project is complete.

On the Wireframes page, create an iPhone 16 Pro frame (393 by 852 pixels). Apply a 4-column layout grid with 16-pixel margins and 16-pixel gutters. This is the structural foundation of your mobile design. Every element you place will align to this grid.

Switch to the Final Design page and create an identical frame. Apply the same grid. Now open the Local Styles panel and define your color palette before placing a single design element.

Finio uses a dark-to-light color scheme with a primary accent of deep teal. Define the following color styles: Background/Dark (#0F1923), Background/Card (#1A2736), Brand/Primary (#0FBCB6), Text/Primary (#FFFFFF), Text/Secondary (#8A9BB0), Status/Success (#2ECC71), Status/Warning (#F39C12).

Define three text styles: Heading/Large (Inter Bold, 28px, line height 36px), Body/Regular (Inter Regular, 16px, line height 24px), and Label/Small (Inter Medium, 12px, line height 16px, letter spacing 0.5px uppercase).

15.2 Wireframing the Layout

Return to the Wireframes page. Before committing to colors and typography, sketch the layout using only grey-filled rectangles and placeholder text. This is how professional designers think before they style: structure first, aesthetics second.

The Finio Home screen needs to contain the following content sections in this vertical order: a top navigation area with a greeting and notification icon, a balance card showing the total balance prominently, a quick actions row with icon buttons for Send, Receive, Pay, and More, a spending summary section with a simple chart area, and a recent transactions list with at least three entries.

Place grey rectangles for each of these sections with approximate heights and widths. Do not worry about exact values yet. Label each rectangle with the section name using a text element. The goal of this wireframe step is to confirm that the layout makes sense spatially before any visual design begins.

Review your wireframe by zooming out to see the full frame. Ask yourself whether the most important information (the balance) is prominent enough. Ask whether the user can understand the screen's purpose within two seconds of seeing it. If the answer to either question is no, rearrange the sections before moving forward.

15.3 Building the Design System Foundation

Switch to the Components page. You are going to build three components before designing the actual screen: a Transaction Item component, a Quick Action Button component, and a Balance Card component. Building these as components first means your final design will be consistent and easily editable.

Transaction Item Component

Create a frame 361 pixels wide (the column width minus margins) and 64 pixels tall. Add Auto Layout with 16px horizontal padding and 0px vertical padding. Inside it, place a 40x40 circle for the merchant icon (use a color fill from your Brand palette), a vertical stack of two text elements (merchant name in Body/Regular Text/Primary and category in Label/Small Text/Secondary), and an amount text element right-aligned (positive amounts in Status/Success, negative in Text/Primary).

Quick Action Button Component

Create a 72x72 frame. Inside it, place a 48x48 circle with Brand/Primary fill for the icon background, and a label text below it in Label/Small Text/Secondary. Create four instances on the Components page: Send, Receive, Pay, and More, with different icon placeholders (use simple geometric shapes as placeholder icons for now).

Balance Card Component

Create a frame 361 pixels wide and 180 pixels tall. Add a Background/Card fill and a 16px corner radius. Inside: a Label/Small text reading "TOTAL BALANCE" in Text/Secondary, a large Heading/Large text showing "$12,450.80" in Text/Primary below it, a horizontal row showing monthly change data in Label/Small at the bottom, and a subtle teal gradient overlay element using Brand/Primary at 8% opacity.

15.4 Designing the Final Screen

Switch to the Final Design page. Your frame is ready with the grid applied. Now assemble the screen using the components you built.

Set the frame background to Background/Dark. Working from top to bottom within the frame:

Place the greeting section first. A Heading/Large text reading "Good morning, Alex" in Text/Primary on the left. A 40x40 notification bell icon (draw a simple bell shape using ellipse and rectangle boolean operations) on the right, with a small 8x8 Brand/Primary dot positioned at the top right of the bell for the unread indicator.

Below the greeting, place your Balance Card component instance. Ensure it respects the 16-pixel margins on both sides.

Below the balance card, place a row of four Quick Action Button instances with equal spacing between them using Auto Layout.

Build the spending summary section manually: a Label/Small header "SPENDING THIS MONTH" in Text/Secondary, and below it a simplified chart placeholder — a row of seven rounded rectangles of varying heights representing a week-by-week bar chart, filled with Brand/Primary at varying opacity levels to suggest data.

Finally, build the transactions list. Place a "Recent Transactions" heading using Body/Regular at medium weight in Text/Primary. Below it, place three Transaction Item component instances with realistic data: a coffee shop purchase, a grocery store transaction, and an incoming transfer.

15.5 Polish and Review

With all sections in place, switch off the layout grid (Command + Shift + 4) and review the screen as a user would see it.

Check the visual hierarchy: is the balance the most visually dominant element? It should be. Is the greeting warm but unobtrusive? It should be. Do the transaction items read cleanly at their small size?

Check spacing consistency: measure the vertical gap between each section using Figma's measurement tools (hold Option/Alt while hovering over gaps with an element selected). All major section gaps should be 24 pixels. All internal component gaps should follow the 8-point grid.

Check alignment: every text element and component should align to the column grid. Hold down Command (or Control) and click on any element to see its position values in the right sidebar. Nothing should have a fractional pixel value (avoid positions like X: 16.5 — round to the nearest whole pixel).

Finally, add a subtle refinement that separates polished designs from adequate ones: add a very soft radial gradient overlay to the top of the screen — a Brand/Primary circle at 3% opacity, 400 pixels in diameter, centered at the top of the frame. This creates a barely perceptible warm glow from the brand color that makes the dark background feel designed rather than plain.

Save a named version: "Finio Home — V1 Complete."

  

Chapter 16

Project 2: Build a Landing Page

Project Brief

You are designing a landing page for a fictional productivity tool called Focusly — a web application that helps remote teams run better async meetings through structured agendas, action item tracking, and AI-generated meeting summaries.

The landing page has one job: to convince a visitor who has never heard of Focusly to sign up for a free trial. Every design decision — the hero headline, the feature layout, the social proof, the call-to-action — should serve that single conversion goal.

16.1 Setting Up the File

Create a new Figma file named "Focusly — Landing Page." Create three pages: Wireframe, Desktop Design, and Mobile Design. You will design at two breakpoints: 1440 pixels wide (desktop) and 390 pixels wide (mobile).

On the Desktop Design page, create a frame 1440 pixels wide. Set the height to 5200 pixels — you will design the full page vertically within this single tall frame, with overflow scrolling enabled. Apply a 12-column layout grid with 80-pixel margins and 24-pixel gutters.

Focusly's color palette uses a clean, modern palette built on deep indigo and fresh lime. Define these color styles: Background/Page (#FAFAFA), Background/Dark (#0F0F1A), Brand/Primary (#4F46E5), Brand/Accent (#A3E635), Text/Primary (#111827), Text/Secondary (#6B7280), Text/Inverse (#FFFFFF), Border/Default (#E5E7EB).

Define text styles for the desktop scale: Display/Hero (Inter Bold, 72px, line height 80px, letter spacing -2px), Heading/H2 (Inter Bold, 48px, line height 56px, letter spacing -1px), Heading/H3 (Inter Semi Bold, 32px, line height 40px), Body/Large (Inter Regular, 20px, line height 32px), Body/Regular (Inter Regular, 16px, line height 26px), Label/Nav (Inter Medium, 16px, line height 24px).

16.2 Planning the Page Structure

Before building, map out the full page section structure as a content wireframe. A high-converting SaaS landing page follows a proven psychological sequence: attention, interest, desire, action. Your page sections should mirror this sequence.

The section order for the Focusly landing page is: Navigation Bar (attention — establish credibility and provide escape routes), Hero Section (attention — bold headline, subheadline, primary CTA, and a hero image of the product), Social Proof Bar (interest — logos of recognizable company types using Focusly), Feature Section One (interest — the primary pain point and how Focusly solves it), Feature Section Two (desire — a second key feature shown in more detail), Feature Section Three (desire — a third key feature completing the value proposition), Testimonials (desire — real voices validating the claims), Pricing (desire — making the decision feel easy), Final Call to Action (action — one more opportunity to convert), and Footer (trust and navigation).

Sketch each section as a rough wireframe on the Wireframe page using grey rectangles and text labels, just as you did in Project One. Confirm the sequence makes sense as a narrative before building the final design.

16.3 Building Section by Section

Navigation Bar

Create a frame 1440 pixels wide and 72 pixels tall. Add a white fill and a very subtle bottom border (1px, Border/Default). Inside, place the Focusly logotype (design a simple wordmark using Inter Bold with "Focus" in Text/Primary and "ly" in Brand/Primary). Center-right: navigation links in Label/Nav style for Features, Pricing, and About. Far right: a "Log in" ghost button and a "Start free trial" filled button in Brand/Primary. Apply Left and Right constraints to the full navigation bar so it stretches to any page width. Apply appropriate individual constraints to each element.

Hero Section

This is the most important section of the entire page. Give it approximately 800 pixels of vertical height. The left column (spanning 7 of the 12 grid columns) contains: a small pill-shaped label in Brand/Accent background reading "Now with AI summaries ✦" in small semi-bold text, the hero headline in Display/Hero style ("Run meetings your team actually prepares for"), a subheadline in Body/Large Text/Secondary style (two lines describing the core value proposition), and two CTAs side by side — a primary "Start for free" button in Brand/Primary and a secondary "Watch demo →" ghost button.

The right column (spanning 5 of the 12 grid columns) contains a browser window mockup frame showing a simplified UI preview of the Focusly application. Design this as a stylized flat illustration: a browser chrome bar at the top (with three dots and a URL bar), and inside the browser, a simplified meeting agenda interface showing an agenda item list, participant avatars, and a progress indicator.

Social Proof Bar

A full-width section with a Background/Dark fill and 80px vertical padding. A small centered label reading "Trusted by teams at" in Text/Inverse at 40% opacity. Below it, a row of five company type wordmarks (create stylized placeholder company names like "Meridian", "Vortex Co", "Atlasworks", "Nuvelo", "Crestfield") in a muted white at 50% opacity. These should be centered and evenly spaced.

Feature Sections

Design three feature sections with alternating image-left / image-right layouts. Each section should be approximately 600 pixels tall and use the full 12-column grid. The text content occupies 5 columns and the product screenshot illustration occupies 7 columns (alternating sides between sections). Each feature section has a Label/Small category tag in Brand/Primary color, an H3 heading, a Body/Regular description (2-3 sentences), and a bullet-style list of three specific benefits using Brand/Accent checkmark icons.

16.4 Completing the Page

Testimonials Section

Create a section with a Background/Page fill and three testimonial cards arranged in a three-column grid. Each card: white background, 16px corner radius, 32px internal padding, a five-star row in amber, a quote in Body/Regular italic, and a footer row with a circular avatar placeholder, a name in Body/Regular medium weight, and a role in Label/Small Text/Secondary.

Pricing Section

Three pricing tier cards (Free, Pro, Team) in a three-column layout. The Pro tier card uses Brand/Primary as its background fill with Text/Inverse for all text, visually distinguishing it as the recommended option. Each card: tier name in Heading/H3, price in a large Display/Hero style, a feature list with checkmarks, and a CTA button at the bottom. The Pro card's CTA is white-filled with Brand/Primary text. The other cards' CTAs are Brand/Primary outlined.

Final CTA Section

A full-width section with Brand/Primary background, centered content: a short H2 headline ("Stop surviving meetings. Start owning them."), a Body/Large subheadline, and a single prominent white-background button with Brand/Primary text. Add a subtle decorative element: a large low-opacity circle (Brand/Accent at 8% opacity) centered behind the headline for visual interest.

Footer

A dark Background/Dark section with four column groups: the Focusly logotype and a short description on the left, and three link columns (Product, Company, Legal) to the right. At the bottom, a horizontal rule and a copyright notice in Label/Small Text/Secondary.

16.5 Responsive Mobile Version

Switch to the Mobile Design page and create a 390-pixel wide frame. Apply a 4-column grid with 20-pixel margins.

Adapt each desktop section for the mobile viewport: the navigation becomes a simplified bar with just the logo and a hamburger menu icon, the hero section stacks vertically (text above, browser mockup illustration below), the feature sections stack fully vertically with the illustration above the text, the testimonials become a single-column list, the pricing tiers stack vertically, and the footer collapses its columns into a single stacked layout.

Create a separate set of mobile text styles with reduced sizes: Display/Hero becomes 42px, Heading/H2 becomes 32px, Heading/H3 becomes 24px. These smaller sizes are necessary because at 390 pixels wide, the desktop Display size at 72 pixels would be nearly full-width and would lose its impact.

  

Chapter 17

Project 3: Create a Design System From Scratch

Project Brief

The previous two projects gave you designs that work. This project gives you a design system that scales. A design system is not a project deliverable — it is infrastructure. It is the foundation that makes every future project faster, more consistent, and more professional.

You are building the Figma design system for a fictional brand called Orbit UI — a design system that could serve any SaaS product. By the end of this chapter, you will have a complete, documented, and usable design system with foundations, components, and usage documentation that you can adapt and extend for real projects.

17.1 Setting Up the System Architecture

Create a new Figma file named "Orbit UI — Design System." This file will be organized with the following pages in this exact order: Cover, Foundations, Components, Patterns, and Documentation.

The Cover page is the first thing anyone sees when they open the file. Design it as a simple but polished cover: the Orbit UI name in large bold type against a dark background with a subtle radial glow effect. Include a version number (v1.0), a last-updated date, and a brief one-sentence description of what the system contains.

Establishing the Foundation Variables

Before creating any component, you must define all foundation values as named styles and variables. Orbit UI's foundations cover four areas: Color, Typography, Spacing, and Elevation.

Color foundations use a systematic palette scale. Define twelve shades for the primary hue (Blue/50 through Blue/950 using a consistent lightness curve), twelve for a secondary hue (Purple/50 through Purple/950), eight neutral shades (Neutral/0 through Neutral/950), and five semantic color scales: Success (green family), Warning (amber family), Danger (red family), Info (blue-grey family), and Neutral. Map semantic aliases on top: Interactive/Primary → Blue/600, Interactive/Hover → Blue/700, Interactive/Active → Blue/800, Surface/Default → Neutral/0, Surface/Subtle → Neutral/50, Text/Default → Neutral/950, Text/Subtle → Neutral/500.

Typography foundations define a complete type scale. Orbit UI uses Inter as its primary typeface. Define scales for size (11, 12, 13, 14, 16, 18, 20, 24, 30, 36, 48, 60, 72px), weight (Regular 400, Medium 500, Semi Bold 600, Bold 700), and line height. Combine these into named text styles: Display/2XL, Display/XL, Display/LG, Heading/XL, Heading/LG, Heading/MD, Heading/SM, Body/LG, Body/MD, Body/SM, Body/XS, Label/LG, Label/MD, Label/SM, Code/MD.

Spacing foundations use a 4-point scale: define spacing variables for 0, 2, 4, 6, 8, 10, 12, 16, 20, 24, 32, 40, 48, 56, 64, 80, 96, 120, 160px. Name them Space/0 through Space/160.

17.2 Building the Core Components

With foundations defined, you can now build components. Orbit UI's core component library covers seven categories. Build all main components on the Components page, organized in labeled section frames.

Button The Button is your most-used component. Build a complete Button component set with the following variant properties: Variant (Primary, Secondary, Tertiary, Danger, Ghost), Size (SM, MD, LG), State (Default, Hover, Active, Disabled, Loading), and Leading Icon (True, False) and Trailing Icon (True, False).

Primary/MD/Default: Blue/600 background, Neutral/0 text, Inter Semi Bold 14px, 10px vertical padding, 16px horizontal padding, 8px corner radius.

Use component properties to expose the label text, the leading and trailing icon slots (using an Icon component instance), and the loading state's spinner animation placeholder. Build the complete grid of all variant combinations within a single component set.

Input The Input component covers text fields. Properties: State (Default, Focus, Filled, Error, Disabled), Size (SM, MD, LG), and Has Label (True, False), Has Helper Text (True, False), Has Leading Icon (True, False).

Input/MD/Default: Neutral/0 fill, Neutral/200 border (1px), 8px corner radius, 10px vertical padding, 12px horizontal padding. Focus state: Blue/500 border (2px). Error state: Danger/500 border (2px) with a red helper text. The label sits above the input field as a floating label element.

Badge A small status indicator. Properties: Variant (Neutral, Primary, Success, Warning, Danger, Info), Size (SM, MD), Style (Solid, Subtle, Outline).

Card A container component. Properties: Padding (None, SM, MD, LG), Border (True, False), Shadow (None, SM, MD, LG).

Avatar Properties: Size (XS, SM, MD, LG, XL), Type (Image, Initials, Icon), Status (None, Online, Offline, Busy, Away).

Checkbox and Toggle Both interactive components. Build with On/Off states wired as interactive components. Include Indeterminate state for Checkbox. Include Label (True, False) and Helper Text (True, False) properties.

Navigation Build a Side Navigation component with collapsible sections, active state indicators, and nested item support. Build a Top Navigation component for web contexts with logo, navigation links, and action buttons.

17.3 Building Composite Components

Composite components are built from core components. They represent higher-order UI patterns used in product screens.

Modal Dialog

A composite component combining Card (as the container), a header frame with title and close button, a content slot (a component placeholder frame), and a footer frame with two Button instances (typically Cancel and Confirm). Properties: Size (SM, MD, LG, Full), Has Footer (True, False).

Form Field Group

A vertical stack of Input components with a section title, used for form construction. Properties: Number of Fields (2, 3, 4).

Empty State

A centered composition for zero-data states. Contains an illustration placeholder frame, a Heading/MD title, a Body/MD description, and an optional Button. Properties: Has Button (True, False), Illustration Size (SM, LG).

Data Table Row

A full-width row component for tabular data. Contains a checkbox column, configurable data cells, a status Badge instance, and an action menu trigger. Properties: Selected (True, False), Has Checkbox (True, False).

Notification Toast

A floating notification component. Properties: Variant (Success, Warning, Danger, Info), Has Title (True, False), Has Action (True, False), Has Close Button (True, False). Width: 360px fixed.

17.4 The Patterns Page

Patterns are larger, screen-level templates assembled from components that demonstrate how the system is used in real product contexts. They are not designs of specific products — they are generalized reference layouts showing best-practice assembly.

Build four patterns on the Patterns page: a Settings Page pattern (showing a side navigation, a page header, and a form section with Input components and a save Button), a Data Table pattern (showing a table header with filters and a search Input, a Data Table Row repeated eight times with alternating background, and pagination controls), an Authentication Form pattern (showing a centered Card containing a logo placeholder, a form with two Input fields, and a primary Button, matching the layout of a typical login screen), and a Dashboard Overview pattern (showing a top navigation, four metric cards in a row, a large chart placeholder card, and a recent activity list).

These patterns serve as the most practical reference in the design system — when a designer starts a new screen, they can begin from a pattern rather than from scratch.

17.5 Documentation and Handoff Preparation

The final step in building Orbit UI is documentation. A design system without documentation is a library without a catalogue — technically complete but practically inaccessible.

On the Documentation page, create a documentation frame for each core component. Each documentation frame should include the component itself rendered in its most common variant, a usage guidelines section (when to use this component, and when not to), a properties table listing every variant property and its possible values, a do/don't comparison showing correct and incorrect usage, and accessibility notes including minimum contrast ratios, keyboard interaction expectations, and ARIA role information.

Document the foundations on separate frames: a color reference showing every color style with its hex value, its semantic alias (if applicable), and its intended use case; a typography scale reference showing each named text style rendered at actual size with its full specification; and a spacing scale reference showing each spacing value as a visual block with its variable name and pixel value.

Before publishing the library, complete a final audit: every component should use foundation color styles rather than raw hex values, every text element inside a component should use a named text style, every component should have clear, systematic naming, and every component's properties should be documented in its component description field (accessible by selecting the main component and clicking the information icon in the right sidebar).

Publish the library from the main Figma menu. The Orbit UI design system is now available as a shared library for any file in your team workspace.

  

Chapter 18

Project 4: Design and Prototype an Onboarding Flow

Project Brief

You are designing and fully prototyping the onboarding flow for a mental wellness app called Serene. Onboarding is one of the most critical flows in any consumer application — it is the first experience a new user has with your product, and research consistently shows that the quality of onboarding directly determines whether users return after their first session.

Serene's onboarding has two goals: to personalize the experience for each user (by collecting information about their wellness needs and goals) and to demonstrate the app's value before asking for a subscription commitment. The flow should feel calm, welcoming, and effortless — precisely aligned with the app's wellness positioning.

18.1 Planning the Flow

Before opening Figma, map the complete onboarding flow on paper or in FigJam. The Serene onboarding consists of ten screens in this sequence: Splash Screen, Welcome Screen, Goal Selection (multi-select), Mood Check-in (daily habit), Experience Level, Notification Permission Request, Personalized Plan Reveal, Free Trial Offer, Account Creation, and Home Screen (the destination the flow arrives at).

Each screen has a specific job in the user's psychological journey. The first three screens establish warmth and gather data without friction. The middle screens make the data collection feel rewarding rather than intrusive. The final screens present the value proposition and convert the user to a registered account at the moment their engagement is highest.

Map the flow as a simple diagram showing all ten screens as labelled boxes, the primary linear path connecting them with arrows, and any branching paths (what happens if the user skips a step, denies notification permission, or selects different goals).

Document the primary use case path — the path a user takes when they complete every step as designed. This is the path your prototype will demonstrate.

18.2 Setting Up the File

Create a new Figma file named "Serene — Onboarding Flow." Create three pages: Flow Map, Screens, and Prototype Notes.

On the Flow Map page, recreate your paper diagram digitally. Use simple rounded rectangle frames labeled with screen names, connected by arrows drawn with Figma's line tool. Color the primary path arrows in Serene's brand color and mark any branching paths in a lighter grey. This diagram will be your reference throughout the design process.

On the Screens page, create ten iPhone 16 Pro frames (393 by 852 pixels) arranged in two rows of five. Name each frame precisely: 01-Splash, 02-Welcome, 03-Goals, 04-Mood, 05-Experience, 06-Notifications, 07-PlanReveal, 08-Trial, 09-Account, 10-Home. The numbering prefix ensures the frames appear in order in the layers panel.

Serene's visual identity is built on calmness. Define the following color styles: Background/Dawn (#FFF9F3), Background/Dusk (#1A0D2E), Brand/Sage (#7FB5A0), Brand/Lavender (#9B8EC4), Brand/Warm (#F4A261), Text/Dark (#1A0D2E), Text/Medium (#5A4E6B), Text/Light (#FFFFFF), Overlay/Soft (a gradient from Brand/Lavender at 60% to Background/Dusk at 100%).

Define text styles: Display/Serif (Playfair Display Bold, 40px, line height 48px), Heading/Sans (Inter Semi Bold, 24px, line height 32px), Body/Regular (Inter Regular, 17px, line height 26px), Label/Button (Inter Semi Bold, 16px, line height 24px).

18.3 Designing the Screens

Design each screen with the care of a finished deliverable. These screens will be prototyped and may be shown in portfolio presentations, so visual quality matters.

01-Splash

Full-screen Background/Dusk fill. Centered: the Serene logotype in Playfair Display Bold at 48px in Text/Light, a thin horizontal rule in Brand/Lavender at 40% opacity, and a tagline "Find your calm" in Inter Light italic 18px in Text/Light at 70% opacity. A soft radial gradient in Brand/Lavender at 15% opacity blooms from the center behind the logotype. This screen displays for 2.5 seconds before automatically transitioning to the Welcome screen.

02-Welcome

Background/Dawn fill. Upper 55% of the screen: a large illustration area — design this as a stylized abstract illustration using organic shapes in Brand/Sage, Brand/Lavender, and Brand/Warm, creating a calming scene (gentle hills, soft circles suggesting sun or moon, soft organic forms). Lower 45%: a Display/Serif headline "Your wellness journey starts here", a Body/Regular description (two lines), and a full-width "Get started" button in Brand/Lavender fill with Text/Light text. Below the button, a small "Already have an account? Sign in" link in Text/Medium.

03-Goals

Background/Dawn fill. Heading/Sans: "What brings you to Serene?" Body/Regular subtitle in Text/Medium: "Select all that apply". Below: a 2x3 grid of goal selection cards. Each card (170px wide, 110px tall, 16px corner radius) shows a centered emoji, a two-word label, and a white fill with a Border/Default 1px stroke. In the selected state, the card has a Brand/Lavender fill at 15% and a Brand/Lavender 2px border. The six goals: Reduce Stress, Sleep Better, Build Focus, Manage Anxiety, Improve Mood, and Daily Mindfulness. A "Continue" button at the bottom is disabled (grey, Label/Button at 40% opacity) when zero goals are selected and enabled when one or more are selected.

04-Mood

Background/Dusk fill. A soft question in Display/Serif: "How are you feeling today?" Five large mood selector circles in a horizontal row, each with an emoji and a label below: Struggling, Low, Neutral, Good, Thriving. The selected mood circle expands slightly (from 64px to 72px diameter) and gains a white ring border — this state change will be prototyped using variants. A "Continue" button appears below only after a mood is selected.

05-Experience

Background/Dawn fill. Heading/Sans: "Your experience with mindfulness?" Three large radio-style selection cards stacked vertically: "Complete beginner", "Some experience", and "Regular practitioner", each with a brief description in Body/Regular Text/Medium. Selection cards use the same style as Goals — border highlight on selection.

06-Notifications

Background/Dawn fill. Large notification bell illustration (create from basic shapes, similar icon scale to the Welcome illustration). Heading/Sans: "Stay on track with gentle reminders". Body/Regular description explaining the value of notifications (two lines). Two buttons: a primary "Allow notifications" in Brand/Sage fill and a secondary "Maybe later" ghost button in Text/Medium. This screen must branch: Allow leads to 07-PlanReveal. Maybe later also leads to 07-PlanReveal (the app works without notifications — this is a soft ask, not a gate).

07-Plan Reveal

Background/Dusk fill with a celebratory feel. A soft animated confetti effect placeholder (five small diamond shapes in Brand/Warm, Brand/Sage, and Brand/Lavender scattered in the upper half of the screen at various sizes and rotations). Heading/Sans in Text/Light: "Your plan is ready, [Name]". Body/Regular in Text/Light at 80% opacity: "We've created a personalized daily practice based on your goals". Below: three small plan preview cards in a horizontal scroll row, each showing a planned session (icon, session name, duration). A full-width "See my plan" button in Brand/Lavender.

08-Trial

Background/Dawn fill. A centered card (Background/Dusk, 32px corner radius, full width minus 32px margins) containing: a "✦ 7-day free trial" badge in Brand/Warm, a Display/Serif headline "Try everything, free", a list of four premium features with Brand/Sage checkmarks, a full-width "Start free trial" button in Brand/Lavender, a small "No credit card required" caption in Text/Medium below the button. Behind the card, a soft background illustration of abstract organic shapes at low opacity.

09-Account

Background/Dawn fill. Heading/Sans: "Create your account". Two input fields (Email and Password) using Orbit UI Input component styling adapted to Serene's palette. A full-width "Create account" button. Below: "Or continue with" and two social sign-in buttons (Google and Apple) as outlined buttons with their respective logos. At the bottom: "By creating an account, you agree to our Terms and Privacy Policy" in Body/Small Text/Medium.

10-Home

Design a simplified version of Serene's Home screen — the destination. Background/Dawn fill. A greeting: "Good evening, Maya" in Heading/Sans. A today's session card in Background/Dusk with a play button, session title "Evening Wind-Down", and duration "12 min". A "Your streak: 1 day ??" progress indicator. A horizontal scroll row of four session category chips. This screen does not need to be fully designed — it is the landing point of the prototype and primarily communicates that onboarding is complete.

18.4 Building the Prototype

Switch to the Prototype tab. Set the starting frame to 01-Splash. Set the device to iPhone 16 Pro and the background to #1A0D2E (matching the splash screen background for a seamless device frame appearance).

Splash Transition

On 01-Splash, with nothing (or the frame itself) selected, set an interaction: Trigger — After Delay (2500ms). Action — Navigate To. Destination — 02-Welcome. Animation — Dissolve. Duration — 600ms. Ease In and Out. This creates the automatic splash screen transition.

Welcome to Goals

Connect the "Get started" button on 02-Welcome to 03-Goals. Trigger — On Click. Action — Navigate To. Animation — Move In from right. Duration — 350ms. Ease Out.

Goal Selection Interactivity

The goal selection cards require variant interactions. Build the Goal Card as an interactive component with two variants: Unselected and Selected. Wire the On Click trigger to toggle between states. Place six instances of this component on 03-Goals. Connect the "Continue" button to 04-Mood.

Mood Selection

Build the Mood Circle as an interactive component with five variants (one per mood) plus selected/unselected states. Wire the selection trigger using On Click → Change To selected variant. The "Continue" button (initially invisible using a Boolean component property) becomes visible when a mood is selected. Connect Continue to 05-Experience.

Continue the Flow

Connect each subsequent screen's primary CTA to the next screen in the sequence, using Move In from Right at 350ms Ease Out for all forward navigation. The 06-Notifications screen branches: both buttons connect to 07-PlanReveal (same destination, different label intent).

Smart Animate Transitions

For the transition between 07-PlanReveal and 08-Trial, use Smart Animate instead of Move In. This creates a smooth morph between the celebration reveal and the trial offer, feeling more like a single continuous experience than two separate screens.

Back Navigation

On screens 03 through 09, add a back chevron icon in the top left. Connect each back button to the previous screen using Navigate To with a Move In from Left animation, creating the correct directional reversal for backward navigation.

18.5 Testing and Refining the Prototype

Press the Play button to launch the prototype. Experience the full flow as a first-time user would, from the splash screen auto-advance through goal selection to account creation.

As you test, evaluate five quality criteria. First, flow continuity: does every screen connect to the next without dead ends? Second, animation quality: do the transition animations feel appropriate for a wellness brand — calm and unhurried rather than snappy and aggressive? If your transitions feel too fast, increase duration to 400ms and check the easing curves. Third, interactive component behavior: do the goal cards toggle correctly? Does the mood selection reveal the Continue button? Fourth, back navigation: do the back buttons correctly return to the previous screen with the appropriate leftward animation direction? Fifth, emotional arc: does the prototype feel like the user is being welcomed and cared for rather than processed through a form sequence?

Refine anything that does not meet these criteria. Small adjustments — a duration increase from 300ms to 400ms, a dissolve instead of a move on the splash transition, a slightly slower Smart Animate on the plan reveal — can significantly alter the emotional quality of the experience.

Save a named version: "Serene Onboarding — V1 Prototype Complete."

Generate the prototype link. Open it in a private browser window and experience it one final time. If you would sign up for this app after going through this onboarding flow, the project is a success.

  

End of Part Six — Proceed to Part Seven: Growing as a Designer

PART SEVEN

GROWING AS A DESIGNER

The technical skills in this article will take you far. But the designers who build lasting, meaningful careers are not simply the ones who know the most keyboard shortcuts or have the largest component libraries. They are the ones who stay curious long after the initial excitement of learning fades. They are the ones who give back to communities that helped them grow. They are the ones who develop a way of seeing the world — not just screens and pixels, but human behavior, communication, and the invisible friction between people and the things they use.

Part Seven is about all of that. It is about the ecosystem that exists around Figma and how to use it intelligently. It is about the practical steps between knowing how to design and building a career from that knowledge. And it is about the mindset that will carry you through the inevitable periods of doubt, comparison, and creative frustration that every designer experiences.

The tool knowledge is behind you. The real work begins now.

Chapter 19

Figma Plugins and the Community

19.1 Must-Have Plugins for Beginners

The Figma plugin ecosystem contains thousands of tools built by designers and developers around the world. Navigating it as a beginner can feel overwhelming. The following list is deliberately curated and focused — these are the plugins that will meaningfully improve your workflow from the earliest stages of your Figma practice.

Unsplash

Already discussed in Chapter 7, Unsplash deserves first mention here because it is the single most universally useful plugin for beginners. The ability to populate image frames with real, high-quality photography in seconds eliminates one of the most common friction points in early design work: having nothing realistic to design with. Install it immediately and reach for it every time you need photographic content.

Iconify

Two hundred thousand icons from over a hundred and fifty open-source libraries, searchable from a single interface, insertable as editable SVGs directly into your canvas. No other icon plugin comes close to Iconify's combination of coverage and convenience. Make it your default icon source and you will rarely need to leave Figma to find the icon you need.

Figma Tokens / Variables Studio

As you begin working with design systems and color styles, the limitations of Figma's native style management become apparent for larger projects. Figma Tokens (now evolving into Variables Studio) allows you to manage design tokens — the named values that underpin your entire visual system — as structured JSON data. This makes it possible to sync your design tokens with your development team's codebase, ensuring that what exists in Figma and what exists in the product's code stay in alignment. This plugin introduces concepts that may feel advanced at first, but understanding it early will accelerate your growth toward professional-level design systems work significantly.

Stark

Accessibility is not optional in professional design. Stark is an accessibility plugin that checks color contrast ratios against WCAG (Web Content Accessibility Guidelines) standards, simulates how your designs appear to users with different types of color blindness, and provides a focus order visualization showing how keyboard and screen reader users will navigate your interface. Running a Stark check before declaring any design finished is a professional habit that separates considerate design from careless design.

Lorem Ipsum / Content Reel

Placeholder text is a necessary part of early design work, but "Lorem ipsum dolor sit amet" is actively misleading — it does not represent the actual text lengths, character distributions, or language patterns of real content. Content Reel populates your designs with realistic names, email addresses, job titles, product descriptions, and more. Use it to make your mockups reflect reality rather than abstraction.

Noise and Texture

This plugin generates and applies noise textures to any selected frame, adding a subtle grain effect that gives designs a more tactile, premium quality. Noise overlays have become a common technique in modern UI design for adding depth and warmth to flat color backgrounds. The plugin is simple but produces effects that would take significant manual effort to replicate with Figma's native tools.

Auto Flow

Auto Flow draws elegant, curved arrows between your frames directly on the canvas, making it easy to create flow diagrams and user journey maps without manually drawing and connecting shapes. It is invaluable for the flow mapping exercises in Part Six and for any design documentation that needs to communicate navigation structure visually.

Minimap

As your Figma files grow in complexity, navigating a large canvas becomes increasingly challenging. Minimap adds a small overview panel to the corner of your workspace showing a bird's-eye view of the entire canvas, with a highlight indicating your current viewport position. Clicking anywhere in the minimap instantly navigates to that area of the canvas.

19.2 Using the Figma Community for Inspiration

The Figma Community is one of the most underutilized resources available to designers at every level. It is not simply a marketplace for templates — it is a living archive of how professional designers think, organize, and execute their work.

How to Access and Navigate the Community

From the Figma home screen, click the Community tab in the left sidebar. The Community home shows featured files, trending resources, and curated collections. You can browse by category (UI Kits, Icons, Illustrations, Wireframes, Prototypes, Presentations) or search by keyword. Filtering by most liked or most duplicated surfaces the resources that the community has found most valuable, which is a reasonable proxy for quality.

Using Community Files as Learning Material

This is the most powerful and least discussed use of the Figma Community. When a professional designer publishes a polished UI kit or design system to the community, they are also publishing a detailed record of how they think. Open any high-quality community file and examine it not just for the visual output but for the structure behind it: how are the layers named? How are the components organized? What naming convention do the color styles use? How deep does the component hierarchy go? How are variants structured?

This kind of reverse engineering — taking apart a professional's file to understand how it was built — is one of the fastest learning accelerators available to any designer. It exposes you to professional standards and conventions that would otherwise take years of team experience to encounter.

Curating an Inspiration Library

Create a dedicated Figma file called "Inspiration Library." When you find a piece of design in the community or anywhere on the web that you admire, analyze why you admire it. Then recreate the aspect you find compelling from scratch in your Inspiration Library file. Do not copy the design — reconstruct the principle. If a particular card layout uses spacing and shadow in a way that feels refined, build that card yourself from scratch, figuring out the exact values that make it work. This practice is called visual deconstruction, and it builds design intuition far faster than passive browsing.

Following Designers and Teams T

he Figma Community allows you to follow individual designers and teams. Following designers whose work you respect creates a curated feed of new resources as they publish them. Some of the most influential contributors to the Figma Community include the teams behind major design systems (Material Design, Atlassian Design System, IBM Carbon) and individual designers who regularly publish educational resources.

19.3 Templates, When to Use Them

Templates are pre-designed Figma files that provide a structural starting point for a specific type of design work. The Figma Community and various third-party providers offer templates for everything from mobile app UI kits to pitch deck frameworks to wireframing libraries.

Templates are genuinely useful in specific circumstances, and actively harmful in others. Understanding the difference will help you use them intelligently rather than as a crutch.

When Templates Genuinely Help

Templates are most valuable when speed is the priority and learning is not. If you need to produce a quick prototype for a client meeting and you have done this kind of work many times before, starting from a well-structured template is a legitimate professional efficiency choice. Templates are also valuable as reference material — seeing how a template organizes its layers, components, and styles gives you ideas you can apply to your own custom files.

Wireframing templates are particularly useful for beginners because they provide a library of low-fidelity UI components (grey box buttons, placeholder text, generic icons) that can be assembled quickly into screen layouts without getting distracted by visual design decisions before the structure is validated.

When Templates Are Harmful

Templates become harmful when they substitute for learning. If you use a UI kit template to produce a design that looks professional without understanding why each design decision was made, you have produced output without building capability. The design looks good because the template designer made good decisions — not because you did. When a client or employer asks you to justify a design choice, or when the template's conventions do not fit a new brief, you will have nothing to fall back on.

The other common failure mode is over-dependence on a template's visual aesthetic. Many template-dependent designs are identifiable as such because they share the same visual language — the same rounded corners, the same card shadows, the same color palette, the same icon style — as dozens of other designs built from the same template. Originality in design comes from developing your own aesthetic judgment, and that judgment only develops through practice that requires you to make decisions yourself.

A Practical Rule

Use templates for wireframing and structural reference. Build your final visual designs from scratch using your own component library and style system. This balance gives you the speed advantages of templates at the stages where visual judgment is not yet required, while preserving the design thinking that produces genuinely original, considered work at the stages where it matters most.

19.4 Contributing Back to the Community

The Figma Community has given you free icons, free UI kits, free educational files, and free templates. At some point in your design journey — perhaps sooner than you expect — you will have something worth giving back.

What You Can Contribute

You do not need to be an expert designer to contribute meaningfully to the Figma Community. You need only to have created something that someone else would find useful. The projects in Part Six of this article, once completed and polished, are legitimate community contributions. A design system you build for a personal project, cleaned up and documented, has value to other designers who are building similar systems. A wireframing kit you assembled for your own workflow might save another designer hours. An icon set you created to match a specific aesthetic that did not exist in any existing library fills a genuine gap.

The Figma Community is built by designers at every level of experience. Some of its most popular resources were contributed by designers who published their very first significant project. The community does not discriminate by years of experience — it responds to usefulness and quality.

How to Publish to the Community

To publish a file to the Figma Community, the file must be in a team workspace on a paid plan. Open the file you want to publish, go to the Share settings, and click the Publish to Community option. You will be prompted to add a title, description, thumbnail image (design this carefully — it is what determines whether people click on your resource), and category tags.

Write the description with specificity: what does the file contain, who is it for, and what problem does it solve? A detailed, honest description attracts the right audience and sets appropriate expectations.

The Habit of Public Work

Beyond formal community contributions, developing the habit of working in public — sharing works in progress on design communities like Dribbble, Behance, LinkedIn, and Twitter/X, writing about your process, showing early iterations alongside final results — builds something that completed projects alone cannot: an audience and a reputation.

Sharing imperfect work is uncomfortable. It requires tolerating the vulnerability of having your developing skill visible to others. Most designers avoid it for exactly this reason, which means those who embrace it immediately distinguish themselves. The designers who document their learning publicly attract mentors, collaborators, clients, and employers to them rather than having to seek all of these things outward.

Chapter 20

What Comes Next?

20.1 Building Your Design Portfolio

Your portfolio is the single most important career asset you have as a designer. It is more important than your resume, your degree, your job title, or your years of experience. Hiring managers and clients make decisions about designers within minutes of looking at their portfolio, and almost every design opportunity you pursue will begin with a portfolio review.

What Belongs in Your Portfolio

A portfolio should contain three to five case studies that together demonstrate range, process, and quality. Three strong, well-documented projects are significantly more compelling than ten mediocre ones. Quantity is not a substitute for depth.

Each case study should tell a story: the problem being solved, the constraints that shaped the solution, the process followed (research, wireframing, iteration, testing), the final design with high-quality mockups, and the outcome (what changed, what was learned, what would be done differently). The process is as important as the result. Hiring managers are trying to understand how you think, not just what you can make.

Using Your Figma Projects as Portfolio Work

The four projects in Part Six of this article are portfolio-ready, with the following caveat: they must be presented as learning projects honestly, not disguised as client work. There is no shame in including student work or self-initiated projects in a portfolio — many designers do, particularly at the beginning of their careers. The key is framing: present the project brief, explain what you were trying to learn or demonstrate, show your process, and discuss what you would improve.

If you want to move beyond self-initiated projects, consider contributing to open-source design projects, volunteering design work for non-profit organizations, participating in design challenges (Figma's own design challenges, Dribbble weekly warm-ups, and community design sprints all provide structured briefs), or reaching out to early-stage startups who may need design help in exchange for portfolio rights and experience.

Portfolio Presentation

Your portfolio can live in several formats. A Figma prototype is a perfectly acceptable and often impressive portfolio format — it allows you to control the presentation experience precisely and demonstrates Figma proficiency at the same time. A dedicated portfolio website on platforms like Framer, Webflow, or Cargo gives you more public visibility and a professional web presence. A PDF case study document can be useful for email applications but should not be your primary format.

Whatever format you choose, apply the same design standards to your portfolio that you would to any other professional design project. Typography, spacing, color, and layout should all reflect the level of craft you claim to possess. An inconsistently designed portfolio undermines the case it is supposed to make.

20.2 Getting Your First Design Job or Freelance Client

The path from learning Figma to earning from design looks different for different people. There is no single correct route, but there are consistently effective strategies that shorten the journey.

The Job Seeker Path

If your goal is a full-time design role, the hiring process for junior and mid-level product designers is fairly standardized. Applications are reviewed on portfolio first, then resume. Portfolios that advance to an interview typically demonstrate at least one case study showing user research informing a design decision, screen-level designs of sufficient visual quality, and some evidence of prototyping or interactive design capability. The bar for a first role is real but not as high as many beginners fear: hiring managers at most companies are primarily looking for evidence of potential, learning ability, and clear thinking — not the finished expertise of a senior designer.

Specialize early. Rather than presenting yourself as a designer who can do everything, identify the intersection of where your skills are strongest and where there is genuine market demand. UI-focused roles suit designers who have exceptional visual craft. UX-focused roles suit designers who can demonstrate research, testing, and systems thinking. Product design roles benefit from both. Knowing which direction you are leaning helps you target your portfolio and your job search more precisely.

Reach out to designers who work at companies you admire and ask for a brief informational conversation, not a job. Ask about their career path, what they look for in junior candidates, and what they wish they had known earlier. These conversations consistently produce more useful intelligence than any job board, and they occasionally turn into referrals.

The Freelance Path

Freelancing requires a different starting strategy. Clients hire freelancers they trust, and trust is built through three things: demonstrated competence (portfolio), social proof (recommendations and referrals), and perceived professionalism (how you communicate, present, and follow through).

Your first freelance clients are almost never strangers. They are people who already know you: a friend starting a business, a former colleague whose company needs design help, a local organization whose website you have noticed needs improvement. These warm connections lower the trust barrier enough for an unknown designer to get a first opportunity.

Charge fairly for your work from the beginning. The instinct to undercharge in exchange for experience is understandable but counterproductive. Clients who pay very little tend to be more demanding, less respectful of boundaries, and less likely to provide the quality of work and feedback that advances your career. A portfolio built from low-fee projects can itself signal to future clients that your work is not worth investing in.

20.3 Resources to Keep Learning

Figma is a tool in motion. It is updated regularly, and features that did not exist when you started learning may be central to professional practice within a year. Staying current requires ongoing investment in learning, and the quality of your learning resources matters.

Official Resources

Figma's own documentation at help.figma.com is comprehensive, clearly written, and always current. When a new feature launches, Figma publishes both written documentation and often a video tutorial within days. Making a habit of reading Figma's release notes (published on their blog at figma.com/blog) keeps you aware of new capabilities as they arrive.

Figma also publishes Config talks — presentations from the annual Figma conference — on their YouTube channel. These talks are given by designers working on some of the most sophisticated design systems and workflows in the industry, and they represent the highest level of practical Figma knowledge available publicly.

Community Learning

The Figma Community Discord server and the Figma subreddit (r/FigmaDesign) are active communities where designers ask questions, share work, and discuss technique. These peer-to-peer learning environments provide answers to specific questions that documentation does not always address and expose you to the real-world problems that designers are encountering and solving.

Design-focused YouTube channels including those of Pablo Stanley, AJ&Smart, and Mizko publish high-quality Figma tutorials regularly. Unlike the broad foundational content of this article, these channels tend to focus on specific techniques, workflows, and case studies — they are ideal continuing education once the foundations are solid.

Books That Deepen Design Thinking

Figma proficiency is the technical layer. Design thinking is the intellectual layer. Several books are consistently recommended by design practitioners as foundational to developing genuine design intelligence. The Design of Everyday Things by Don Norman introduces the psychology of human interaction with designed objects and environments — it will change how you perceive every product you encounter. Thinking with Type by Ellen Lupton provides the typographic depth that a single chapter in a Figma book cannot. About Face by Alan Cooper remains one of the most thorough treatments of interaction design principles available. Sprint by Jake Knapp provides the practical framework for rapid design and validation that many product teams use as their default process.

The Practice of Daily Looking

No book or course substitutes for the habit of daily intentional visual observation. Spend fifteen minutes every day looking at exceptional design. Not passively, but analytically. Use services like Mobbin, Screenlane, and Nicelydone to browse real app screenshots. Use Dribbble and Behance for curated design work. Use Siteinspire and Awwwards for web design. For each piece you look at, force yourself to articulate specifically what works and why. What is the spacing doing? How does the color hierarchy guide the eye? What makes the typography feel considered rather than arbitrary?

This practice costs nothing, requires no software, and over months and years produces the kind of refined visual intuition that technical instruction alone cannot build.

20.4 The Designer Mindset

Everything in this article has been about knowledge and skill — what to know and how to do it. This final section is about something harder to teach and more important to possess: the way of thinking that makes a designer effective across every project, every tool, and every career stage.

Design Is Problem Solving, Not Decoration

The most persistent misconception about design is that it is primarily an aesthetic discipline — that designers are people who make things look good. This misunderstanding limits both how non-designers see the field and, when internalized, how designers see themselves.

Design is the discipline of solving human problems through intentional creation. The aesthetic dimension of design is not irrelevant — visual quality communicates care, builds trust, and affects how people feel while using a product. But aesthetics in service of no purpose is decoration. Design in service of human needs is design. Every decision in a well-designed product, from the placement of a button to the wording of an error message to the duration of a transition animation, exists because someone thought carefully about what a person needs in that moment and made a choice to serve that need.

Carry this definition with you in every project. When you find yourself making a visual choice, ask whether the choice serves a human need or simply satisfies your own aesthetic preference. Sometimes these are the same thing. When they are not, the human need wins.

Embrace Iteration

Every first design is wrong. Not wrong in the sense of being without merit, but wrong in the sense that it will be improved by revision. The designers who make the best work are not the ones who get it right first — they are the ones who iterate the most without losing energy or conviction.

Develop a relationship with feedback that is genuinely curious rather than defensive. When a stakeholder, a user, a developer, or a colleague points out a problem with your design, their observation is data. It may be imprecisely articulated or motivated by factors that are not purely design-related, but there is almost always a real underlying signal in any piece of negative feedback worth understanding.

The worst response to feedback is to treat it as an attack on your judgment and resist it. The second worst response is to implement every piece of feedback exactly as given, deferring your own design judgment entirely. The correct response is to understand the problem being identified, evaluate it against what you know about the users and the goals, and make the revision that genuinely best serves the design — which may or may not resemble what was suggested.

Stay Uncomfortable

The periods of fastest growth in any designer's career are the periods when they are working at the edge of their current capability — taking on projects that are slightly too complex, using techniques they have not fully mastered, designing in unfamiliar contexts.

Competence feels good. It is efficient, reliable, and confidence-building. But it is also static. You do not grow by doing what you already know how to do. The habit of deliberately seeking projects and challenges slightly beyond your comfort level — then working through the discomfort to deliver — is the engine of continuous development.

this article introduced you to Figma. What it cannot do for you is make you sit down and design something difficult on a day when it feels easier not to. That is the practice. That is where design careers are actually built.

See People, Not Users

The language of design — users, user flows, user testing, user needs — is unavoidable and useful, but it can subtly depersonalize the people your work is ultimately for. Behind every product you design are real human beings with specific circumstances, anxieties, hopes, and limitations. The person using the Finio finance app is not a user managing a portfolio. They are a person worried about whether their rent is covered. The person using the Serene wellness app is not a user completing an onboarding flow. They may be someone who has been having a very hard year and is looking for something that helps.

The best design work comes from designers who carry genuine curiosity and care for the people their products serve. This is not sentiment — it is craft. Designs made with real empathy for real people solve real problems in ways that designs made for abstract user types rarely do.

Glossary of Design Terms

The following terms appear throughout this article and represent the core vocabulary of digital product design. Understanding these terms precisely will help you communicate clearly with other designers, developers, and stakeholders.

Anchor Point — A point on a vector path that defines the shape of the path. Anchor points can be corners (creating sharp angles) or smooth (creating curves). In Figma, anchor points are visible and editable when a vector shape is in edit mode.

Auto Layout — A Figma feature that allows frames to automatically resize and reflow their contents based on defined rules for direction, spacing, and padding. Auto Layout mirrors the behavior of CSS flexbox and is essential for building responsive, scalable components.

Boolean Operation — A mathematical operation applied to two or more vector shapes to create a new combined shape. The four boolean operations in Figma are Union, Subtract, Intersect, and Exclude.

Brand — The totality of how an organization is perceived, including its visual identity, tone of voice, values, and the emotional associations it builds with its audience. In design practice, brand is expressed through consistent application of color, typography, imagery, and interaction style.

Canvas — The infinite working surface in Figma on which all design elements are placed. The canvas has no fixed boundaries and can be navigated by zooming and panning.

Component — A reusable design element in Figma that can be placed as multiple instances throughout a project. Changes to the main component propagate automatically to all instances. Components correspond to reusable elements in frontend code such as React components.

Component Set — A group of component variants organized together in Figma, allowing designers to define multiple states and types of a component within a single organized structure.

Constraint — A property that defines how an element behaves when its parent frame is resized. Constraints can anchor elements to the edges, center, or proportional position within their parent.

Design System — A collection of reusable components, design guidelines, and standards that define the visual and interaction language of a product or organization. A design system includes foundations (color, typography, spacing), components, patterns, and documentation.

Design Token — A named value that stores a design decision (such as a color, spacing value, or font size) in a format that can be shared between design tools and code. Design tokens create a single source of truth for visual properties across design and development.

Easing — The acceleration profile of an animation. Easing determines whether an animation starts fast or slow, and how it decelerates or accelerates over its duration. Common easing types include Linear, Ease In, Ease Out, and Ease In and Out.

Frame — A bounded container in Figma that defines a layout area. Frames support layout grids, Auto Layout, constraints, and clipping. In prototyping, frames represent individual screens. Frames are the primary structural element of any Figma design.

Gradient — A fill type that transitions smoothly between two or more colors. Figma supports Linear, Radial, Angular, and Diamond gradient types.

Grid — A system of columns, rows, or squares overlaid on a frame to guide the consistent placement of design elements. Layout grids in Figma are non-destructive overlays that can be shown or hidden without affecting the design.

Handoff — The process of delivering a completed design to a development team for implementation. A design handoff includes the Figma file with organized layers and components, exported assets, and any necessary annotations explaining behavior and specifications.

Hex Code — A six-character alphanumeric string that identifies a specific color in web and digital design. Hex codes represent the red, green, and blue channels of a color in hexadecimal notation. Example: #4F46E5 is a deep indigo.

Instance — A copy of a main component placed in a design. Instances inherit the properties of their main component and update automatically when the main component changes, while allowing local overrides to specific properties.

Layer — Any individual design element in Figma (frame, shape, text, image, component) that appears in the layers panel. Layers are organized hierarchically, with parent elements containing child elements.

Line Height — The vertical space occupied by a line of text, typically expressed as a pixel value or as a percentage of the font size. Line height affects the readability and visual density of text.

Mask — A technique in Figma where a shape defines the visible area of an element placed beneath it. Content outside the mask shape is hidden. Masks allow images and other elements to be revealed through any custom shape.

Opacity — The degree of transparency of a layer, expressed as a percentage from 0% (fully transparent) to 100% (fully opaque). Distinct from the opacity of a specific fill or stroke, which affects only that property rather than the entire layer.

Overflow — Content within a frame that extends beyond the frame's visible boundary. Frames can be set to clip overflow (hide it) or to allow scrolling through it.

Padding — The internal spacing between the edge of a container and its contents. In Figma, padding is defined within Auto Layout frames and mirrors the CSS padding property.

Prototype — An interactive simulation of a design that connects frames with interactions and animations, allowing users to experience a design's flow and behavior without the product being built in code.

Radial Gradient — A gradient that transitions from a center point outward in a circular pattern. Radial gradients are commonly used for glow effects and spotlight backgrounds.

Stroke — A border applied to the edge of a shape or path. Strokes have configurable color, width, and style (solid, dashed, dotted), and can be positioned inside, outside, or centered on the element's boundary.

Text Style — A saved typography configuration in Figma that captures font family, weight, size, line height, letter spacing, and other typographic properties. Text styles can be applied to any text element and updated globally.

Variant — A version of a component that differs from other versions in one or more defined properties. Variants of the same component are organized together in a component set and can be switched between in designs and prototypes.

Vector — A type of graphic defined by mathematical paths rather than pixels. Vectors scale to any size without losing quality. SVG files are a web-standard vector format.

Viewport — The visible area of a screen at any given moment. Content that exists outside the viewport requires scrolling or navigation to access.

Wireframe — A low-fidelity design representation that communicates layout and structure without visual styling. Wireframes use placeholder elements to establish content hierarchy before visual design decisions are made.

Acknowledgements

this article exists because of a community, the vast, generous, international community of designers who share their knowledge openly, challenge each other's thinking honestly, and collectively push the practice of digital design forward in ways that no individual could manage alone.

To the team at Figma, whose relentless commitment to building a tool that serves designers at every level of experience has made this article both possible and necessary — thank you for building something worth writing about.

To every designer who has published a free resource to the Figma Community, written a tutorial, recorded a walkthrough, answered a question in a forum, or taken the time to give honest feedback to a stranger's portfolio — you are the reason the barrier to entering this field is lower today than it was ten years ago. That matters enormously.

To the students and early readers who worked through drafts of this material and asked the questions that exposed every assumption, every skipped step, and every moment where the explanation assumed more than it should have — this article is clearer and more useful because of your honesty.

To the designers who reviewed technical content and caught the errors that would have misled readers — your care for accuracy reflects the rigor the discipline deserves.

To everyone who is reading this article as their first serious encounter with design — you chose to learn something real. That choice is worth respecting, and I hope what you found here honored the seriousness with which you made it.

  

  

---