Send Koji Insights to Linear: Auto-File Engineering Tickets from Customer Interviews

TL;DR: Wire Koji to Linear so every customer interview that surfaces a real pain point auto-creates a tagged Linear issue with the verbatim quote, theme, study link, and quality score attached. Setup takes about 20 minutes via Zapier (or 2–3 hours via Linear's GraphQL API directly). Most engineering teams report this single integration replaces the "Slack thread → screenshot → ticket title from memory" workflow that everyone hates, and dramatically increases the percentage of customer-driven tickets that actually get prioritized.

Why teams sync Koji to Linear

Linear is where engineering work actually happens. Tickets there get triaged, sprinted, and shipped — which means anything that wants to influence the roadmap needs to live there. Research findings that never reach Linear effectively never reach the roadmap.

The traditional flow looks like this: PM watches an interview recording → takes notes in Notion → writes a Linear ticket from memory → engineering reads the ticket without context → builds something slightly different than what the customer described. By the time the feature ships, the link back to "this is what Dana said in the August interview" is gone, and so is any way to evaluate whether the feature actually solved the problem.

A Koji → Linear sync replaces that whole chain with a webhook. Every completed Koji interview that surfaces a pain point can auto-create a Linear issue containing:

• Verbatim customer quote (not a paraphrase)
• Theme tag from Koji's AI analysis
• Quality score (so engineering can deprioritize low-confidence signal)
• Direct link back to the live Koji interview, so anyone can play the voice clip
• Participant segment and metadata
• Study context and AI summary

This is the modern alternative to manual ticket creation. Platforms like Koji automate moderation, transcription, theme extraction, and quality scoring; Linear becomes the surface where engineering executes against that evidence. The two pieces fit together cleanly through Linear's webhook-friendly architecture.

Integration paths

There are two production-ready ways to send Koji interviews to Linear:

1. Zapier (recommended) — point-and-click, ~20 minutes, supports filters, no code
2. Linear GraphQL API (advanced) — write a webhook receiver that calls Linear's API directly

Most teams should start with Zapier. The GraphQL path is worth it once you need rich formatting (markdown tables, attachments) or you're sending more than a few thousand tickets per month.

Prerequisites

• A Koji study with at least one completed interview
• A Linear workspace where you have permission to create issues in at least one team
• A Zapier account (the Starter plan is needed for filters)
• About 20 minutes

Step 1: Decide which interviews become tickets

This is the most important design decision and the one most teams skip. Do NOT auto-create a Linear ticket for every interview — your engineering backlog will explode and the signal-to-noise will tank within a week.

The patterns that work in production:

• Filter by quality score. Only create tickets from interviews with quality score 4 or higher (out of 5). This drops gibberish and accidental submissions automatically.
• Filter by theme. Only create tickets when Koji's AI detects a theme that maps to engineering work — e.g. "bug-report", "performance-issue", "missing-feature". Themes like "general-praise" or "competitor-mention" should never become tickets.
• Filter by structured-answer threshold. If your study has a scale question like "How easy was this?", auto-create a ticket only when the participant rates it 2 or below — those are the real problems worth filing.
• Filter by sentiment. Negative-sentiment interviews are usually the higher-leverage ones to file.
• Combine filters. "Quality score 4+ AND theme contains 'bug' OR scale rating <= 2" is the kind of multi-condition filter Zapier handles natively.

Write down which filter you want before you start the integration. You can always change it later, but having a default rule prevents the first-day backlog explosion.

Step 2: Set up the Koji webhook

In Koji:

1. Open the study you want to monitor
2. Go to Settings → Webhooks (or the Webhooks tab in the study editor)
3. Add a new webhook destination — leave the URL field empty for now

You'll paste the Zapier URL here in the next step.

Step 3: Create the Zap

In Zapier:

1. New Zap → Trigger: Webhooks by Zapier → Catch Hook
2. Zapier gives you a URL. Copy it.
3. Paste it into the Koji webhook destination, save the Koji study, then fire a "Test webhook" from Koji
4. Back in Zapier, click "Test trigger" — you should see a real Koji payload with study ID, interview ID, quality score, themes, structured answers, transcript text, and the public URL

Step 4: Add the filter step

Click "+ Add step" → Filter by Zapier. Add your conditions. For the most common "bug-or-pain" filter:

• interview.quality_score is greater than or equal to 4
• AND interview.themes text contains bug OR pain OR frustration OR confusion

You can chain ANDs and ORs natively. Zapier's filter UI makes this easier than writing it in code.

Step 5: Create the Linear issue

Add a new action: Linear → Create Issue. Connect your Linear account. Configure:

• Team: the engineering team that owns this study's surface area (e.g. "Onboarding", "Billing", "Search")
• Title: map to interview.headline if Koji generates one, otherwise build it from the theme + participant ID — e.g. [Research] {theme}: {participant_name}
• Description: the most important field. Build it from these blocks (markdown supported in Linear):

**Quote:** "{interview.headline_quote}"

**Theme:** {interview.themes}
**Quality score:** {interview.quality_score}/5
**Segment:** {interview.metadata.segment}
**Study:** {study.title}

**AI summary:** {interview.ai_summary}

**Listen to the interview:** {interview.public_url}

---
Auto-filed from Koji. Edit or close if not actionable.

• Labels: map to interview.themes — Linear will create the labels on the fly if they don't exist (or you can pre-create the labels you care about)
• Priority: map to a formula — if quality score >= 5 then "High", if 4 then "Medium", else "Low"
• Assignee: leave empty so triage handles it (most teams) or set to a designated triage owner

Test the action. The Linear issue should appear in your team's inbox within seconds.

Step 6: Turn the Zap on and tune

Toggle the Zap to "On." Watch it for a week and tune the filter based on what you see. The most common adjustment: tightening the theme list because your initial filter was too permissive.

Patterns that pay off

Auto-link to existing issues

Add a Zapier "Find Issue" step before "Create Issue." Search by theme tag. If an issue already exists for that theme, add a comment to the existing one instead of creating a duplicate. This is huge for keeping the backlog clean when the same pain shows up across multiple interviews.

Severity-based team routing

Use a Zapier Paths step. Route interviews with the bug theme to the platform team, pricing to the growth team, and onboarding to the activation team. Each path can have its own filter and its own Linear team mapping.

Auto-close confirmation tickets

When Koji's AI detects a feature-praise theme that mentions a recently shipped feature, you can auto-comment on the Linear issue that originally tracked the work and close it. This closes the customer-research loop without any human intervention.

Weekly digest issues

Instead of one ticket per interview, run a Zapier Digest action: aggregate all interviews from a study for the past 7 days, then create one Linear ticket with all the quotes grouped by theme. This is the right pattern for steady-state insight ingestion vs. urgent bug surfacing.

Block deploys on research signal

Pair this with your release process: a Linear ticket tagged block-release from a Koji interview can fail your release checklist. This is overkill for most teams but useful for safety-critical products.

The Linear API approach (if you outgrow Zapier)

Linear's GraphQL API is one of the cleanest issue-tracker APIs around. If you outgrow Zapier:

1. Stand up a webhook receiver (Vercel, Cloudflare Workers, AWS Lambda)
2. Verify Koji's webhook signature (HMAC)
3. Transform the payload into a Linear IssueCreateInput
4. Call issueCreate via Linear's GraphQL endpoint with a personal API key
5. Optionally: call issueLabelCreate to ensure labels exist before tagging

This typically takes a senior engineer half a day. The advantage is markdown formatting, file attachments, custom views, and per-issue webhook callbacks back to Koji for closed-loop research.

Common pitfalls

• Label explosion. If you map every Koji theme to a Linear label without filtering, your label list will balloon. Pre-create the 10–15 labels you care about and let Zapier skip the rest.
• Quote truncation. Linear issue titles are limited to ~256 characters. Use a Zapier Formatter step to truncate the headline before mapping.
• Stale evidence. Six months in, the original interview may be archived in Koji. Make sure your Linear ticket includes the participant ID and study ID — not just the URL — so the evidence can be re-fetched even if the URL changes.
• Triage burnout. Even with good filters, expect 5–15 tickets per week from a moderately active research program. Assign a rotating triage role so no one person owns the whole queue.
• Customer privacy. Verbatim quotes can contain identifying information. If your participants are under a strict NDA, anonymize quotes in the Zapier Formatter step before they hit Linear.

Why this changes how engineering teams ship

The biggest lift from a Koji + Linear integration is not the time saved on ticket creation — it's the change in what gets prioritized. Once every backlog ticket has a verbatim customer quote attached, the discussion in standup shifts from "should we build this?" to "how do we solve what this person said?" Quality scores let you weight signal honestly. Theme tags let you batch similar pains. And the link back to the live interview means anyone — engineer, designer, exec — can play the voice clip and form their own opinion in 30 seconds. That's a fundamentally different decision-making loop than the one most teams have today, and it's the kind of compounding advantage that the modern AI-native research stack makes possible.

Related resources

• Connect Koji to Zapier — the foundational webhook + Zapier guide
• Sync Koji Research Insights to Notion — pair with Linear for full research-to-execution flow
• Sync Koji to HubSpot — push insights to sales workflows
• Send Research Insights to Slack — real-time notifications
• Koji Webhook Setup — payload reference
• Koji Structured Questions Guide — the 6 question types Linear will receive
• Closing the Loop on Customer Feedback — turn shipped tickets into follow-up interviews
• User Research API — full API reference for direct integration