Microsoft Teams + Linear: tickets logged without chasing
Your Teams channels weren’t meant to be a ticket queue. But that’s what happens: a request lands in chat, somebody reacts with “I’ll take it,” and then it disappears under 40 more messages.
Teams Linear automation hits Product leads first because they’re the ones juggling priorities, but support managers and agency owners feel it too. You end up chasing context, recreating the request in Linear, and hoping nothing important was lost in the scroll.
This workflow gives you a clean way to turn chat requests into proper Linear issues (and manage them) so your backlog stays tidy and your channel stays readable.
How This Automation Works
The full n8n workflow, from trigger to final output:
n8n Workflow Template: Microsoft Teams + Linear: tickets logged without chasing
flowchart LR
subgraph sg0["Linear Tool MCP Server Flow"]
direction LR
n0@{ icon: "mdi:play-circle", form: "rounded", label: "Linear Tool MCP Server", pos: "b", h: 48 }
n1@{ icon: "mdi:cog", form: "rounded", label: "Create an issue", pos: "b", h: 48 }
n2@{ icon: "mdi:cog", form: "rounded", label: "Delete an issue", pos: "b", h: 48 }
n3@{ icon: "mdi:cog", form: "rounded", label: "Get an issue", pos: "b", h: 48 }
n4@{ icon: "mdi:cog", form: "rounded", label: "Get many issues", pos: "b", h: 48 }
n5@{ icon: "mdi:cog", form: "rounded", label: "Update an issue", pos: "b", h: 48 }
n3 -.-> n0
n1 -.-> n0
n2 -.-> n0
n4 -.-> n0
n5 -.-> n0
end
%% Styling
classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
classDef disabled stroke-dasharray: 5 5,opacity: 0.5
class n0 trigger
The Problem: Requests Get Lost Between Teams and Linear
A request in Teams is convenient in the moment, then costly later. Someone posts “Can we add SSO?” and a few replies down you have half a spec, two conflicting assumptions, and no owner. Then a teammate has to translate that thread into a Linear issue, copy the right bits, and guess what matters. Miss one detail and you get rework. Miss the whole message and you get a frustrated “did anyone ever look at this?” a week later. Honestly, it’s not the work that hurts. It’s the constant context switching.
None of these alone is the problem. Together, they are.
- Teams messages don’t enforce structure, so key fields like priority and owner are often missing.
- Copying chat content into Linear takes about 10 minutes per request once you include clarifying questions.
- Threads fragment across channels, which means the “final decision” is hard to find later.
- When the backlog isn’t updated quickly, planning meetings turn into memory tests.
The Solution: An MCP Server That Creates and Manages Linear Issues
This workflow turns n8n into a ready-to-use “tool server” for Linear. It exposes a single endpoint (a webhook-style MCP trigger) that an AI agent or another workflow can call whenever it needs to work with Linear. When a request comes in, the automation can create a new Linear issue, look up existing issues, fetch details, update fields, or even delete an entry if something was logged by mistake. The key benefit is that you stop treating issue creation like a manual admin chore. Instead, it becomes a reliable action that can happen the moment the request is made, while context is still fresh.
The workflow starts when your agent hits the MCP URL from the trigger node. From there, n8n routes the request to the correct Linear operation (create, update, get, list, delete) and returns the native Linear response. You end with a real Linear issue in the right place, not a vague Teams message someone has to decipher later.
What You Get: Automation vs. Results
| What This Workflow Automates | Results You’ll Get |
|---|---|
|
|
Example: What This Looks Like
Say your team logs about 12 requests a day from Teams. If it takes roughly 10 minutes to turn each chat thread into a proper Linear issue (title, description, priority, links), that’s about 2 hours daily. With this workflow, the “manual” part becomes a quick structured prompt or form-like message that your agent sends to the MCP endpoint, which usually takes a minute or two. The rest is automated issue creation and a clean Linear response back. Net result: you get most of those 2 hours back, and the backlog stays current.
What You’ll Need
- n8n instance (try n8n Cloud free)
- Self-hosting option if you prefer (Hostinger works well)
- Linear for creating and updating issues.
- Microsoft Teams to capture requests where they start.
- Linear API key (get it from Linear settings under API).
Skill level: Intermediate. You’ll connect credentials, copy a webhook URL, and do light testing with real requests.
Don’t want to set this up yourself? Talk to an automation expert (free 15-minute consultation).
How It Works
An MCP endpoint receives the request. The workflow starts at the Linear MCP Trigger node, which gives you a URL you can hand to an AI agent or another internal tool.
The request is translated into the right Linear operation. Based on what the agent asks for, n8n routes to one of the prebuilt Linear tool actions, like create, update, fetch details, or retrieve a list.
Linear responds with a native payload. You get the real Linear response structure back, which makes it easy to confirm what was created and store IDs for later updates.
Your Teams-to-backlog loop gets tighter. Pair this server with a Teams message capture workflow (or a lightweight agent inside Teams) so new requests become issues while the conversation is still happening.
You can easily modify which fields are required (like priority or team ID) to match how you triage work. See the full implementation guide below for customization options.
Step-by-Step Implementation Guide
Step 1: Configure the MCP Trigger
This workflow is initiated and orchestrated by Linear MCP Trigger, which exposes the Linear tools to an MCP-compatible client.
- Add the Linear MCP Trigger node to your canvas.
- Leave the default parameters as-is unless your MCP client requires custom settings.
- Confirm the trigger is connected to the tool nodes as ai_tool connections.
Step 2: Connect Linear Tools
The workflow exposes five Linear operations as AI tools: create, update, fetch, list, and delete issues.
- Ensure the following nodes are present: Generate Issue Record, Modify Issue Record, Fetch Issue Detail, Retrieve Issue List, and Remove Issue Entry.
- Verify each tool node is connected to Linear MCP Trigger via the ai_tool connection.
- Do not add credentials directly on these tool nodes.
Step 3: Review Non-Operational Notes
Flowpast Branding is a sticky note included for reference and does not affect execution.
- Keep Flowpast Branding if you want the in-canvas documentation.
- Remove it if you want a clean canvas with only functional nodes.
Step 4: Configure Linear Operations (Optional Defaults)
Each Linear tool can accept parameters from your MCP client. You can also add default values inside the tool nodes if needed.
- Open Generate Issue Record to set any default fields for issue creation.
- Open Modify Issue Record to define default update values if applicable.
- Check Fetch Issue Detail and Retrieve Issue List for any optional query constraints you want to prefill.
- Review Remove Issue Entry if you want to enforce deletion rules on the client side.
Step 5: Test and Activate Your Workflow
Validate the MCP integration and confirm the tools are callable before activating.
- Click Test Workflow in n8n and send a tool request from your MCP client.
- Confirm that a successful request produces Linear API responses for the appropriate tool (create, update, fetch, list, delete).
- Resolve any credential or parameter errors by updating Linear MCP Trigger or the relevant tool node defaults.
- Toggle the workflow to Active once all tool calls succeed.
Common Gotchas
- Linear credentials can expire or lack scopes. If calls start failing, check your Linear API key and workspace permissions in n8n credentials first.
- If you’re calling the MCP endpoint from an AI agent, timeouts happen. Increase the agent timeout or handle retries on the caller side if Linear is slow.
- Generic AI inputs lead to generic issues. Add a “required fields” checklist (team, priority, expected outcome) or you will still be cleaning up the backlog manually.
Frequently Asked Questions
About 20–30 minutes once you have your Linear API key.
No coding required. You’ll mainly connect credentials and test a few example requests.
Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in Linear usage (usually included with your Linear plan) and any AI agent costs if you add one.
Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.
Yes, but you’ll customize the workflow that calls this MCP endpoint, not the MCP server itself. Most teams filter by channel and then pass the right “team”, “project”, and “priority” values into the Create Issue operation. You can also add a dedupe check by calling Retrieve Issue List first (search by keyword or requester) and only creating a new issue when nothing matches.
Usually it’s an expired or incorrect Linear API key saved in n8n. Update the credential, then rerun a single test call to Fetch Issue Detail to confirm the connection. If it still fails, check workspace access and make sure the key belongs to the right Linear organization. Rate limits can also show up when an agent loops too aggressively.
On n8n Cloud Starter, you can handle thousands of executions per month, which is plenty for most small teams.
For this use case, n8n is usually the better fit because you can expose a reusable MCP endpoint, support richer branching logic, and self-host for unlimited executions. Zapier and Make are great for straight-line “when X happens, do Y” flows, but they’re not designed to behave like a tool server your AI agent can call repeatedly. Another practical point: you get more control over error handling and logging, which matters when issue creation is part of your delivery process. If you want, Talk to an automation expert and describe your intake process; it’s easy to tell which approach will be less fragile.
You stop chasing messages and start trusting your backlog again. Set it up once, and your Teams conversations can go back to being conversations.
Need Help Setting This Up?
Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.
