Figma to Linear: Bridging Design and Development Without Copy-Paste
How to integrate Figma with Linear using native embeds, the Figma plugin, and workflow patterns that keep design and engineering in sync.
By Ellis Keane · 2026-03-15
Somewhere in the last year, the design-to-engineering handoff became a genre of workplace theatre. A designer finishes a component in Figma, leaves three carefully worded comments, pastes a link into Slack, and tags the engineer who'll build it. The engineer opens the link two days later, reads two of the three comments, misses a variant, and ships something close enough that nobody notices until QA.
If you've lived through this particular flavour of miscommunication (and I have, repeatedly), you already know the fix isn't "better communication." It's connecting the tools so the context travels with the work. Here's how to integrate Figma with Linear – the native embeds, the plugin, and the three workflow patterns that actually make the connection useful.
What Linear's Figma Integration Actually Does
Linear has supported Figma embeds for a while now, and the basics are solid. Paste a Figma URL into any issue description or comment, and Linear generates an embedded preview of the design. These previews are static by default – Linear freezes them at the point of embedding to preserve context, which is a deliberate choice. You can refresh manually in edit mode, but the design won't silently update underneath you.
You can also attach Figma links as issue attachments, which keeps them organised in the sidebar rather than buried in a comment thread that inevitably grows to forty messages by Thursday.
What the figma linear integration doesn't do is anything bidirectional. Linear sees Figma, but Figma doesn't see Linear. Comments stay where they were written. Status changes don't propagate. If an engineer marks an issue as "Done" in Linear, nobody in Figma knows unless someone tells them – which, in practice, means nobody in Figma knows.
How to Integrate Figma with Linear: Step by Step
The setup is straightforward (thankfully – not everything needs a twelve-step OAuth dance!).
Step 1: Enable the Integration
Head to your Linear workspace settings, then Integrations. Find Figma in the list and click Enable. You'll be redirected to Figma to authorise the connection. Grant access, and you're done with the admin side.
Step 2: Link Frames to Issues
Once enabled, pasting any Figma URL into a Linear issue generates an embedded preview. For best results:
- Link specific frames, not entire files. A link to
figma.com/file/abc123?node-id=42:1337 shows the relevant component. A link to figma.com/file/abc123 shows whatever Figma decides is the default view, which is usually not what you want.
- Use the issue description for the primary design reference. Comments work for iteration, but the description is what engineers read first when they pick up an issue.
- Add the Figma link before the issue enters the sprint. This sounds obvious, but I'm genuinely amazed how often design context gets attached after an engineer has already spent twenty minutes hunting for it.
Step 3: Install the Figma Plugin
Figma has a Linear plugin that lets designers create and update Linear issues directly from the canvas. Select a frame, open the plugin, fill in the issue title and team, and it creates the issue with the Figma link pre-attached. The plugin also supports updating issue status and assignee without leaving Figma.
This flips the design to development handoff from "engineer goes looking for the design" to "designer sends the design to engineering." In our team's experience, that single change cut the "where's the design for this?" Slack messages roughly in half. Trust me, that alone is worth the five minutes it takes to set up!
Where the Native Integration Falls Short
I don't want to undersell what Linear and Figma have built – for a lightweight connection, it works. But there are gaps worth naming, because pretending they don't exist leads to the "we have an integration, why is nothing syncing?" conversation three months down the line.
Comments don't cross over. If a designer leaves feedback in Figma and an engineer responds in Linear, neither sees the other's response without manually checking both tools. In our experience, this comment silo is where most design-to-dev miscommunication originates – not from bad specs, but from conversations happening in two places simultaneously.
Status is one-directional. An issue moving to "In Progress" in Linear doesn't update anything in Figma. The designer has to check Linear (or, more realistically, ask in Slack) to know whether their designs are being built.
No change notifications. When a designer updates a frame that's linked to a Linear issue, the engineer assigned to that issue gets no alert in Linear. Since previews are static by default, the engineer might be building against a version of the design that's already been revised. Unless someone manually refreshes the embed or says something in Slack, the update is invisible.
Workflow Patterns That Bridge the Gaps
Embeds solve the reference problem. These three patterns solve the coordination problem – and they're what determine whether your Figma linear integration actually improves the handoff or just adds another tool connection that nobody maintains.
Pattern 1: Design-Ready Issues
Before a design issue enters the sprint backlog, it needs three things attached in Linear:
- Figma frame link (specific frame, not file)
- Design notes summarising what's changed since the last iteration (because the embedded preview shows current state, not what's new)
- Acceptance criteria that reference the design specifically – "matches the Figma frame" is not acceptance criteria. "Uses the 8px spacing token between card title and subtitle" is.
A few extra minutes of designer prep per issue. The payoff is engineers who can start building without a Slack archaeology expedition first.
Pattern 2: Design Review Labels
Create a custom Linear label – something like "Needs Design Review" – and apply it to issues once they've been built but need the designer to verify the implementation. The trick (and I realise this sounds painfully obvious) is making it part of the issue lifecycle template so it triggers automatically when an issue moves to "In Review." I say this from experience – we created exactly this label, used it religiously for two sprints, then quietly stopped because nobody had templated it. Remember the engineer from the opening who missed a variant and shipped "close enough"? That was a missing design review label.
Pattern 3: Figma Sections as Sprint Maps
For larger projects, dedicate a Figma section or page to the current sprint's designs. Each frame maps to exactly one Linear issue. Name the frames to match the issue identifier – ENG-142 – Card Component Redesign – so engineers can find the right frame without scrolling through forty artboards named "Frame 247."
Making These Habits Stick
The teams I've seen make this work share a few traits: designers link frames before issues enter the sprint (not after engineers complain), engineers apply the review label before marking issues as done (not as an afterthought), and nobody treats Slack as the system of record for design decisions.
That last one matters more than any integration, and if you've ever spent fifteen minutes searching for "that thread where we decided to change the border radius," you know exactly what I mean. Slack is where the design conversations happen, and it's also where they go to disappear. If a design decision was made in a thread, someone needs to update the Figma file or the Linear issue – otherwise it's gone in three weeks, buried under deployment alerts and lunch plans.
"If a design decision was made in a thread, someone needs to update the Figma file or the Linear issue – otherwise it's gone in three weeks, buried under deployment alerts and lunch plans." – Chris Calo
The native Figma-Linear integration handles embedding and reference well. For bidirectional awareness – comments, status, change notifications – you need either manual discipline or a layer that connects context across both tools automatically.
And, if you're connecting more than just Figma and Linear – adding Slack, GitHub, and Notion to the mix – the manual overhead of keeping everything in sync compounds quickly. That's a different conversation, but it's worth having before the next "who changed this design and why didn't anyone tell me?" post-mortem.
Connect Figma, Linear, Slack, and GitHub into one knowledge graph – so design context travels with the work.
Q: Does Sugarbug connect Figma and Linear automatically? A: Yes. Sugarbug ingests signals from both Figma and Linear, correlating design comments and file updates with issue status changes in its knowledge graph. When a designer leaves feedback on a frame, Sugarbug can surface it alongside the relevant Linear issue without anyone copying URLs.
Q: Can Sugarbug track design handoff across Figma, Linear, and Slack? A: Sugarbug connects Figma, Linear, Slack, GitHub, and Notion into a single knowledge graph. Design feedback, engineering discussion, and task status all stay correlated – so context doesn't get lost during handoff.
Q: Does Linear have a built-in Figma integration? A: Yes. Linear's native Figma integration lets you paste Figma URLs into issues to create embedded previews, and use the Figma plugin to create or update issues from the canvas. However, it's one-directional – comments and status changes don't sync between tools.
Q: How do I link a Figma frame to a Linear issue? A: Paste the Figma frame URL into a Linear issue description or comment. Linear generates an embedded preview. You can also use Linear's Figma plugin to create issues directly from the canvas with the link pre-attached.
Q: Why don't Figma comments appear in Linear? A: Linear's native Figma integration embeds design previews but doesn't sync comments between tools. A designer's Figma comment and an engineer's Linear comment exist in separate silos. Tools like Sugarbug bridge this by ingesting signals from both and linking them in a shared knowledge graph.