components

11 posts

figma

The Three Cs of Figma: A Beginner’s Guide to Success | Figma Blog (opens in new tab)

Figma beginners should focus less on memorizing individual features and more on building practical skills through three stages: creation, customization, and collaboration. The author argues that this framework makes learning more structured and helps users progress from making simple designs to creating reusable resources for their teams. Learning by doing, seeking help, and setting realistic milestones are central to that progression. ## Establishing Goals, Timelines, and Mindset - Define what you want to learn and how Figma fits into your role, whether in design, development, product management, or education. - Suggested milestones: - **30 days:** Learn basic tools, collaboration practices, and file organization. - **60 days:** Pilot projects and identify knowledge gaps. - **90 days:** Add more advanced features to your workflow. - Adopt a hands-on learning approach by experimenting, making mistakes, and rebuilding. - Share work and ask questions through coworkers, Slack, social media, or the Figma Community Forum. - Take breaks and allow time for unfamiliar tools and processes to become natural. ## The Three Cs of Figma - **Creation:** Learn to make a basic design element. - **Customization:** Use advanced features to make the element flexible and reusable. - **Collaboration:** Share the work with teammates and provide components or documentation they can use. - The three stages function like rungs on a ladder: users first create something, then improve its adaptability, and finally make it useful to others. - Figma’s Help Center, YouTube channel, virtual events, and community resources support this learning process. ## Applying the Framework to a Button - A button provides a practical example of the three Cs: - Create a basic button. - Turn it into a reusable component. - Publish it so teammates can use it in their own files. - This approach connects individual feature knowledge to real design workflows and team collaboration. - Figma provides a playground file for practicing the progression. The practical recommendation is to learn Figma through small, complete projects rather than isolated feature tutorials. Build something, make it reusable, and share it with others while progressing at a sustainable pace.

figma

Embracing the tension between code and design | Figma Blog (opens in new tab)

Figma argues that design and code should not be forced into identical workflows, but should learn from each other. Designers need freedom to explore, while developers benefit from structure, reuse, and consistency. At Config Europe 2020, Figma announced features intended to connect these strengths through more code-like design systems and more efficient handoff. ## Design Systems That Mirror Code - Teams often maintain separate component libraries for design and development, even when the components represent the same product elements. - Differences between the two systems can cause miscommunication and slow implementation. - Figma introduced **Variants**, which group related versions of a component—such as button sizes, styles, interaction states, or platform-specific versions—into one component. - Variants are intended to make Figma components more closely resemble reusable code components and simplify the asset panel. ## Interactive Prototyping with Variants - Before Interactive Components, designers often had to connect multiple frames and overlays to simulate component behavior. - **Interactive Components** allow designers to define prototype transitions directly between Variant states. - This makes component instances immediately interactive in prototype mode and reduces the work required to simulate UI behavior. ## Auto Layout Inspired by CSS - Auto Layout already allowed designs to respond automatically to content changes, such as expanding a button when its label changes. - Figma planned to make Auto Layout more closely match the web’s CSS box model and Flexbox. - Planned improvements included: - A simpler user interface - Stretching elements along both axes - Independent padding controls - Better spacing options for common patterns, such as navigation icons ## Making Large Design Systems Easier to Use - The redesigned **Instance Swap Menu** helps users navigate large component libraries with: - Thumbnails - Search - Keyboard shortcuts - These improvements reduce the need to remember exact component names or browse long lists manually. ## Improving Developer Handoff with Inspect - The new **Inspect Tab** replaces Figma’s Code panel and presents implementation-relevant information more clearly. - It displays the selected layer’s name prominently, helping designers and developers identify what is being built. - Developers can inspect values for Variants, colors, shadows, content, typography, borders, and other properties. - Values and complete key-value snippets can be copied directly into code. Figma’s overall direction is to preserve the creativity of visual design while adding the structure and reusability associated with software engineering. Features such as Variants, Interactive Components, improved Auto Layout, and the Inspect Tab aim to make design systems easier to maintain and translate into production.

figma

What's new in Figma recap | Figma Blog (opens in new tab)

Figma’s spring 2019 updates focused on making everyday design work faster and more scalable. The biggest improvements expanded component workflows and introduced the public beta of the plugin API, enabling the community to build custom tools. The company also highlighted bug fixes and broader product refinements released over the previous three months. ## Component Improvements for Design Systems - Users can select multiple objects and convert them into Components in a single action. - Right-clicking a component instance now reveals related Components in the context menu, making swaps easier. - The **Return to Instance** button lets designers jump to a master component for reference or editing, then return to the instance they were working on. - For local components, instance overrides can be pushed back to the master component, supporting faster iteration and maintenance. ## Public Beta of the Plugin API - Figma launched the public beta of its plugin API after extensive development. - Early community experiments demonstrated how plugins could extend Figma beyond its built-in features. - Examples included: - Generative design tools that repeat text elements radially. - Image-analysis plugins that extract color palettes from selected images. - The strong early response suggested that plugins could support highly specialized creative workflows. ## Quality and Workflow Improvements - Figma dedicated a “quality week” to addressing and fixing a large number of bugs. - The spring release cycle also included rapid improvements to features such as Smart Selection and other frequently used tools. Figma’s spring updates strengthened its core component system while opening the platform to community-built extensions. Designers working with reusable systems could benefit from the component workflow improvements immediately, while the plugin beta offered a foundation for more customized and experimental processes.

figma

5 ways to level up your prototyping workflow in Figma (opens in new tab)

Figma prototyping can be made faster and more realistic by reusing connected components, managing scrolling content centrally, and simulating natural interaction timing. The post presents five techniques that reduce repetitive setup while improving testing, presentation, and collaboration workflows. ## Master Components for Repeated Connections - Turn persistent navigation, such as tab bars or hamburger menus, into master components. - Link each item in the master component once; new instances inherit those prototype connections. - For components from a team library, place the library instance inside a new local master component. - Deep-select nested layers to create links without detaching the instance. ## Components for Scrolling Content - Convert long scrolling content into a component to preview how different device viewports initially crop it. - Set constraints for internal elements and enable **Clip content**. - Configure the desired scrolling direction through **Overflow Behavior** in prototype mode. - Place and resize component instances within designs to compare viewport-specific views while managing content centrally. ## Timed Delays and Overlays - Use the **After Delay** trigger to make transitions feel less abrupt. - Combine timed delays with overlays to simulate loading states or intermediate feedback. - For example, a form can show a submission state, brief loading sequence, and success message before navigating to a confirmation page. ## Table of Contents for Multiple Flows - Create a table-of-contents frame as the prototype’s starting screen. - Link each option to a different user flow, allowing one shared URL to present multiple design alternatives. - All flows must be located on the same Figma page. ## Observation Mode - Use Observation Mode to follow a collaborator’s view in the editor or prototype. - It supports remote user testing by showing where users are and how they interact with the design. - It is also useful for helping meeting participants follow along during presentations. These techniques make Figma prototypes easier to build, reuse, test, and present. Centralizing repeated behavior in components and using realistic timing and navigation can significantly streamline the workflow.

figma

Figma Feature Highlight: Sketch Import | Figma Blog (opens in new tab)

Figma’s Sketch Import feature helps designers move from Sketch to Figma without rebuilding existing work. The post argues that it supports migration, cross-platform collaboration, and hybrid workflows while preserving much of a Sketch file’s structure and fidelity. Users can import files through drag-and-drop, the toolbar, or keyboard shortcuts. ## Why Sketch Import Matters - **Eases the transition to Figma** - Designers switching from Sketch can bring over previous projects instead of recreating them. - This lowers the cost and friction of adopting Figma. - **Supports cross-platform teams** - Sketch is Mac-only, while Figma works across platforms. - Developers and teammates on Windows or Linux can import Sketch files to review designs and specs. - **Enables flexible workflows** - Designers can continue working independently in Sketch and move files into Figma for critiques, comments, and collaboration with remote stakeholders. ## Fidelity and Design-System Support - The importer preserves: - Pages - Resizing constraints - Vectors and other design elements - Sketch symbols are converted into Figma components. - This is particularly useful for teams creating or maintaining shared design systems. - Figma presents the importer as highly accurate, while recommending in-app support if a file does not import correctly. ## How to Import a Sketch File Users can import Sketch files in three ways: - Drag and drop the file into Figma. - Use the import option in the toolbar. - Use: - **Command + Shift + K** on Mac - **Control + Shift + K** on Windows Figma automatically creates a new Figma file containing the imported content. Sketch Import is a practical bridge for teams adopting Figma: it preserves existing work while making collaboration and cross-platform access easier.

figma

How Kiwi.com handles project structure, versioning & components in Figma | Figma Blog (opens in new tab)

Kiwi.com’s small mobile design team uses Figma to bring design collaboration, prototyping, versioning, and handoff into one shared environment. Their previous Sketch workflow depended on Sketch, Zeplin, Abstract, Marvel, and Dropbox Paper, creating frequent synchronization problems. Figma became attractive because it could centralize these activities and support contributions from around twenty collaborators. ## A Small Team with Many Contributors - Kiwi.com’s mobile design team consists of only two people. - Around twenty others contribute through: - Commenting on design iterations - Correcting copy - Designing cross-platform features - The broader front end and Orbit design system were built in Sketch. - Because Orbit’s mobile components differ visually, the team decided to explore building the mobile system in Figma. ## Problems with a Multi-tool Sketch Workflow - Sketch was used alongside: - Zeplin for developer handoff - Abstract for version control - Marvel for static prototypes - Dropbox Paper for embedded PNGs - These tools frequently fell out of sync: - Prototypes could reflect older tested versions. - Designers might forget to commit changes to Abstract. - Zeplin might not contain the latest approved visuals. - Documentation images could be weeks out of date. - The workflow required constant manual coordination between separate sources of truth. ## Why the Team Chose Figma - Figma offered a way to consolidate design work, collaboration, prototyping, and version history. - Its value became clearer in a team where many people needed access to current designs. - The author initially resisted Figma, preferring a native design application over a browser-based tool. - As Kiwi.com’s collaborative needs grew, the advantages of a shared, synchronized workspace outweighed that hesitation.

figma

#FigmaTip Roundup 9.0 | Figma Blog (opens in new tab)

This #FigmaTip Roundup presents practical shortcuts and component techniques shared by the Figma design community. The tips focus on arranging objects efficiently, creating mirrored component variants, and customizing spacing adjustments. Together, they show how keyboard shortcuts and reusable components can speed up common design tasks. ## Arranging Multiple Frames - Use **Cmd + `** to pack selected objects vertically. - Use **Cmd + Shift + `** to pack them horizontally. - Combine these shortcuts with Figma’s alignment commands to quickly reorganize several frames or objects. ## Creating Mirrored Components - To make a flipped, reusable component: - **Option-drag** the original component into a new empty component. - Press **Shift + H** to mirror it horizontally. - The mirrored component remains linked to the original, so changes made to the source component are reflected in the flipped version. ## Customizing Spacing with “Nudge Amount” - Figma’s **Nudge Amount** setting controls how far objects move when using the arrow keys. - Adjusting this value lets designers choose more appropriate spacing increments instead of relying only on the default nudge distance. - This is useful for making precise or larger layout adjustments more efficiently. These techniques provide quick ways to improve layout organization, maintain consistent component variations, and fine-tune spacing directly from the keyboard.

figma

#FigmaTip Roundup 7.0 | Figma Blog (opens in new tab)

FigmaTip Roundup 7.0 collects small, community-shared techniques for working faster and more precisely in Figma. The tips focus on creating symmetrical shapes, controlling selection behavior, zooming directly to layers, and improving frame visibility. Together, they show how shortcuts and view settings can make everyday design tasks more efficient. ## Creating Symmetrical Shapes with Components - Draw a rough outline of one side of a shape, such as a vase or flask. - Convert it into a component with **⌥⌘K**. - Duplicate it with **⌘D**, then mirror the duplicate horizontally with **⇧H**. - Position the mirrored copy beside the original. - Edit the component to refine the shape while preserving symmetry. ## Freezing Selection Bounds - Pressing the **spacebar** freezes the bounds of the current selection. - This helps prevent the selection box from changing while moving or adjusting elements. ## Zooming Directly to a Selection - Enable **“Keyboard Zooms Into Selection”** in Figma’s settings. - This makes it easier to zoom quickly to a selected layer, especially when choosing it from the layers panel. - The feature is useful for navigating complex files with many objects. ## Making Frames Easier to See - The roundup also highlights Figma’s **“Frame Outlines”** view option. - Frame outlines improve visibility and make it easier to distinguish frame boundaries while designing. These shortcuts and settings are simple to adopt but can significantly improve speed, precision, and navigation in Figma.

figma

Tips for using Constraints in your workflow (opens in new tab)

Figma’s constraints feature helps designers build layouts that adapt across different screen sizes and contexts. By anchoring elements to edges, centers, or grids, designs can remain structurally consistent instead of requiring separate manual adjustments. The post presents five practical applications, from simple button placement to flexible navigation bars, table cells, and playful illustrations. ## Pinning Buttons to Corners - Set an action button’s constraints to the bottom and right sides of its parent frame. - This keeps floating action buttons in a consistent location as the screen expands. ## Combining Components and Constraints - Constrain important elements within a frame, then convert the frame into a reusable component. - Duplicate the component for different screen sizes. - Changes to the original—such as colors or text sizes—propagate to all instances, making responsive variations easier to manage. ## Building Flexible Navigation Bars with Grids - Nest a navigation bar frame at the bottom of a phone-screen frame. - Set its constraints to **left & right** and **bottom** so it stretches with the screen. - Apply a layout grid with the **stretch** type. - Place buttons in grid columns and center-constrain them so they reposition as the screen changes. ## Creating Reusable Table Cells - Group related content, such as an avatar and text, and constrain it to the center-left of the cell. - Group action text and a rounded rectangle into a button, then constrain it to the center-right. - The cell’s contents remain attached to their intended sides across different frame widths. ## Experimenting with Illustrations - Horizontal and vertical constraints can also be applied creatively to illustrations. - Stretching constrained artwork can produce humorous distortions and playful effects. Constraints are most useful when combined with components and grids. Setting them thoughtfully allows one design to adapt across many screen sizes while reducing repetitive layout work.

figma

Team Libraries in Figma | Figma Blog (opens in new tab)

Team Libraries bring shared, synchronized components to Figma, addressing the difficulty of maintaining design systems across separate files. The feature builds on Figma’s components, constraints, and web-based collaboration to create a single source of truth that teams can reuse and update efficiently. Its workflow—Publish, Insert, and Update—combines engineering-style structure with an accessible design workflow. ## The Problems with Traditional Design Tools - Many design tools were modeled on print and illustration software rather than interactive applications. - They lack meaningful support for application behavior, platform constraints, and reusable interface structures. - Copying symbols between files creates disconnected versions that must be updated manually. - Large organizations such as Facebook, Google, and Airbnb have had to build custom tools and dedicate staff to maintaining design systems. - Designers need synchronized, compounding component structures to create scalable systems. ## Bridging Design and Dynamic Interfaces - Figma’s earlier features established the foundation for reusable design systems: - Reliable vector editing - Constraints that reflect system behavior - Dynamic, reusable components - Team Libraries extend these capabilities across files and team members. - Because Figma operates online, shared components have effectively no synchronization delay. - Teams can reuse structured components across devices, platforms, layouts, and user flows. ## An Engineering-Inspired Design Workflow - Figma draws on software concepts such as modular composition and frameworks like React. - Structuring interfaces from discrete, clearly defined parts makes products easier to maintain. - The feature adapts engineering principles for designers rather than copying programming workflows directly. ## Publishing Components - Designers select components and choose **Add to Library** in the inspector sidebar. - Multiple components can be collected and reviewed before being published. - Permissions separate the source of truth from its consumers: - Editors of the source file can modify the original components. - Anyone with view access can use the published components. - This lets specialized teams control assets such as icons, colors, or brand guidelines while others reuse them without changing the rules. ## Inserting and Nesting Components - Published components are available in any file for users who can view the source file. - Users insert them through Figma’s components tool. - Components can be nested inside larger components or modules. - Nested structures allow teams to build complex views from reusable source elements while preserving a predictable single source of truth. ## Updating Shared Components - Changes are made to the original component and published again. - Figma provides a confirmation step and a visual diff showing what changed. - Deleting a component from the source file and publishing removes it from the team library. - The update process includes an additional safeguard because changes may affect multiple design explorations and could otherwise cause users to lose work.

figma

Components in Figma | Figma Blog (opens in new tab)

Figma’s 2016 Components release applies software-engineering ideas such as composition, inheritance, and overrides to interface design. Components let designers reuse shared elements as linked instances, so updates remain consistent while local customizations are preserved. The result is a design workflow that supports both systematic reuse and creative flexibility. ## Designing with Components - Components help designers break complex interfaces into smaller, understandable parts. - Reusable elements can appear in multiple locations, at different sizes and with local modifications. - Unlike duplicated copies, component instances remain connected to their source. - Updates to the original component are automatically reflected across all instances, improving consistency and reducing repetitive work. - Examples include repeated address-book rows containing shared typography, spacing, icons, and graphics. ## Figma’s Design Goals Figma aimed to make Components: - Easy for new users to learn. - Powerful enough for advanced design systems. - Flexible throughout the design process. - Low-overhead, so systematic design improves speed without limiting experimentation. ## Creating and Using Instances - Any frame or selected object can be converted into a component through the toolbar. - Duplicating, copying, pasting, or Alt-dragging a component creates instances rather than independent copies. - Instances can move independently on the canvas while retaining their connection to the source component. - Changes made to the main component propagate immediately to its instances. - Certain internal properties, such as the position and size of nested objects, are restricted to make components easier to maintain. ## Style and Property Overrides - Instance changes are treated as overrides of the original component’s properties. - Designers can override fills, strokes, colors, widths, and properties of nested layers. - Overrides remain intact when the source component changes. - Properties that were not overridden continue to update from the source component. - Overrides can be removed with the “Reset Instance” action. ## Complex and Nested Components - Components can contain instances of other components. - Combining nested components makes it possible to build larger systems from smaller, reusable parts. - Designers can add instances to an existing component or create a new component from selected instances. - Nested components are intended to work like other Figma objects, keeping complex systems manageable. ## Constraints - Components can be combined with Figma’s Constraints feature. - Constraints allow elements to respond to changes in size and position. - Together, components and constraints support reusable designs that adapt more intelligently across layouts. Components provide a practical bridge between design and software development: create shared building blocks once, reuse them widely, and preserve controlled customization through overrides. Teams building consistent, evolving interfaces can use them to reduce duplication while keeping designs adaptable.